Unnamed: 0
int64 0
6.7k
| func
stringlengths 12
89.6k
| target
bool 2
classes | project
stringlengths 45
151
|
|---|---|---|---|
2,200
|
private class StartDatabaseAgainKit implements RepairKit
{
private final int serverId;
private final ManagedCluster cluster;
public StartDatabaseAgainKit( ManagedCluster cluster, int serverId )
{
this.cluster = cluster;
this.serverId = serverId;
}
@Override
public HighlyAvailableGraphDatabase repair() throws Throwable
{
cluster.startMember( serverId );
return cluster.getMemberByServerId( serverId );
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,201
|
{
@Override
public void addClusterMemberListener( ClusterMemberListener listener )
{
// noop
}
@Override
public void removeClusterMemberListener( ClusterMemberListener listener )
{
// noop
}
}, clusterClient.getServerId() ));
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,202
|
{
@Override
public void stop() throws Throwable
{
graphDatabase.get().shutdown();
}
} );
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,203
|
{
@Override
public HighlyAvailableGraphDatabase apply( HighlyAvailableGraphDatabaseProxy from )
{
return from.get();
}
}, members.values() );
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,204
|
{
@Override
public GraphDatabaseService call() throws Exception
{
return graphDatabaseBuilder.newGraphDatabase();
}
};
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,205
|
private static final class HighlyAvailableGraphDatabaseProxy
{
private GraphDatabaseService result;
private Future<GraphDatabaseService> untilThen;
private final ExecutorService executor;
public HighlyAvailableGraphDatabaseProxy( final GraphDatabaseBuilder graphDatabaseBuilder )
{
Callable<GraphDatabaseService> starter = new Callable<GraphDatabaseService>()
{
@Override
public GraphDatabaseService call() throws Exception
{
return graphDatabaseBuilder.newGraphDatabase();
}
};
executor = Executors.newFixedThreadPool( 1 );
untilThen = executor.submit( starter );
}
public HighlyAvailableGraphDatabase get()
{
if ( result == null )
{
try
{
result = untilThen.get();
}
catch ( InterruptedException | ExecutionException e )
{
throw new RuntimeException( e );
}
finally
{
executor.shutdownNow();
}
}
return (HighlyAvailableGraphDatabase) result;
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,206
|
{
@Override
public Void call() throws Exception
{
try
{
wrapped.shutdown();
}
catch ( Throwable throwable )
{
throw new RuntimeException( throwable );
}
return null;
}
} );
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,207
|
{
@Override
public Void call() throws Exception
{
try
{
wrapped.stop();
}
catch ( Throwable throwable )
{
throw new RuntimeException( throwable );
}
return null;
}
} );
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,208
|
{
@Override
public Void call() throws Exception
{
try
{
wrapped.start();
}
catch ( Throwable throwable )
{
throw new RuntimeException( throwable );
}
return null;
}
} );
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,209
|
{
@Override
public Void call() throws Exception
{
try
{
wrapped.init();
}
catch ( Throwable throwable )
{
throw new RuntimeException( throwable );
}
return null;
}
} );
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,210
|
private static final class FutureLifecycleAdapter<T extends Lifecycle> extends LifecycleAdapter
{
private final T wrapped;
private Future<Void> currentFuture;
private final ExecutorService starter;
public FutureLifecycleAdapter( T toWrap)
{
wrapped = toWrap;
starter = Executors.newFixedThreadPool( 1 );
}
@Override
public void init() throws Throwable
{
currentFuture = starter.submit( new Callable<Void>()
{
@Override
public Void call() throws Exception
{
try
{
wrapped.init();
}
catch ( Throwable throwable )
{
throw new RuntimeException( throwable );
}
return null;
}
} );
}
@Override
public void start() throws Throwable
{
currentFuture.get();
currentFuture = starter.submit( new Callable<Void>()
{
@Override
public Void call() throws Exception
{
try
{
wrapped.start();
}
catch ( Throwable throwable )
{
throw new RuntimeException( throwable );
}
return null;
}
} );
}
@Override
public void stop() throws Throwable
{
currentFuture.get();
currentFuture = starter.submit( new Callable<Void>()
{
@Override
public Void call() throws Exception
{
try
{
wrapped.stop();
}
catch ( Throwable throwable )
{
throw new RuntimeException( throwable );
}
return null;
}
} );
}
@Override
public void shutdown() throws Throwable
{
currentFuture = starter.submit( new Callable<Void>()
{
@Override
public Void call() throws Exception
{
try
{
wrapped.shutdown();
}
catch ( Throwable throwable )
{
throw new RuntimeException( throwable );
}
return null;
}
} );
currentFuture.get();
starter.shutdownNow();
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,211
|
{
@Override
public void initializeStoreDir( int serverId, File storeDir ) throws IOException
{
copyRecursively( seedDir, storeDir );
}
} );
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,212
|
{
@Override
public boolean accept( ManagedCluster item )
{
for ( HighlyAvailableGraphDatabaseProxy member : item.members.values() )
{
try
{
member.get().beginTx().close();
}
catch ( TransactionFailureException e )
{
return false;
}
}
return true;
}
};
| false
|
enterprise_ha_src_test_java_org_neo4j_test_ha_ClusterManager.java
|
2,213
|
{
@Override
public void release() throws IOException
{
lock.release();
}
};
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralFileSystemAbstraction.java
|
2,214
|
private static class DynamicByteBuffer
{
private static final int[] SIZES;
/**
* Holds a set of pools of unused BytBuffers, where pools are implemented by {@link Queue}s.
* Each pool contains only {@link ByteBuffer} of the same size. This way, we have pools for
* different sized {@link ByteBuffer}, and can pick an available byte buffer that suits what
* we want to store quickly.
*/
private static volatile AtomicReferenceArray<Queue<Reference<ByteBuffer>>> POOLS;
private static final byte[] zeroBuffer = new byte[1024];
synchronized DynamicByteBuffer copy()
{
return new DynamicByteBuffer( buf ); // invoke "copy constructor"
}
static
{
int K = 1024;
SIZES = new int[] { 64 * K, 128 * K, 256 * K, 512 * K, 1024 * K };
POOLS = new AtomicReferenceArray<>( SIZES.length );
for ( int sizeIndex = 0; sizeIndex < SIZES.length; sizeIndex++ )
POOLS.set( sizeIndex, new ConcurrentLinkedQueue<Reference<ByteBuffer>>() );
}
private ByteBuffer buf;
public DynamicByteBuffer()
{
buf = allocate( 0 );
}
/** This is a copying constructor, the input buffer is just read from, never stored in 'this'. */
private DynamicByteBuffer( ByteBuffer toClone )
{
int sizeIndex = sizeIndexFor( toClone.capacity() );
buf = allocate( sizeIndex );
copyByteBufferContents( toClone, buf );
}
private void copyByteBufferContents( ByteBuffer from, ByteBuffer to )
{
int positionBefore = from.position();
try
{
from.position( 0 );
to.put( from );
}
finally
{
from.position( positionBefore );
to.position( 0 );
}
}
/**
* Tries to allocate a buffer of at least the specified size.
* If no free buffers are available of the available capacity, we
* check for buffers up to two sizes larger. If still no buffers
* are found we allocate a new buffer of the specified size.
*/
private ByteBuffer allocate( int sizeIndex )
{
for (int enlargement = 0; enlargement < 2; enlargement++) {
AtomicReferenceArray<Queue<Reference<ByteBuffer>>> pools = POOLS;
if (sizeIndex + enlargement < pools.length()) {
Queue<Reference<ByteBuffer>> queue = pools.get( sizeIndex+enlargement );
if ( queue != null )
{
for (;;)
{
Reference<ByteBuffer> ref = queue.poll();
if ( ref == null ) break;
ByteBuffer buffer = ref.get();
if ( buffer != null ) return buffer;
}
}
}
}
return ByteBuffer.allocateDirect( ( sizeIndex < SIZES.length ) ? SIZES[sizeIndex]
: ( ( sizeIndex - SIZES.length + 1 ) * SIZES[SIZES.length - 1] ) );
}
void free()
{
try
{
clear();
int sizeIndex = buf.capacity() / SIZES[SIZES.length - 1];
if (sizeIndex == 0) for ( ; sizeIndex < SIZES.length; sizeIndex++ )
{
if (buf.capacity() == SIZES[sizeIndex]) break;
}
else
{
sizeIndex += SIZES.length - 1;
}
AtomicReferenceArray<Queue<Reference<ByteBuffer>>> pools = POOLS;
// Use soft references to the buffers to allow the GC to reclaim
// unused buffers if memory gets scarce.
SoftReference<ByteBuffer> ref = new SoftReference<>( buf );
// Put our buffer into a pool, create a pool for the buffer size if one does not exist
( sizeIndex < pools.length() ? pools.get( sizeIndex ) : getOrCreatePoolForSize( sizeIndex ) ).add( ref );
}
finally
{
buf = null;
}
}
private static synchronized Queue<Reference<ByteBuffer>> getOrCreatePoolForSize( int sizeIndex )
{
AtomicReferenceArray<Queue<Reference<ByteBuffer>>> pools = POOLS;
if ( sizeIndex >= pools.length() )
{
int newSize = pools.length();
while ( sizeIndex >= newSize )
newSize <<= 1;
AtomicReferenceArray<Queue<Reference<ByteBuffer>>> newPool = new AtomicReferenceArray<>( newSize );
for ( int i = 0; i < pools.length(); i++ )
newPool.set( i, pools.get( i ) );
for ( int i = pools.length(); i < newPool.length(); i++ )
newPool.set( i, new ConcurrentLinkedQueue<Reference<ByteBuffer>>() );
POOLS = pools = newPool;
}
return pools.get( sizeIndex );
}
synchronized void put( int pos, byte[] bytes, int offset, int length )
{
verifySize( pos+length );
try
{
buf.position( pos );
}
catch ( IllegalArgumentException e )
{
throw new IllegalArgumentException( buf + ", " + pos, e );
}
buf.put( bytes, offset, length );
}
synchronized void get( int pos, byte[] scratchPad, int i, int howMuchToReadThisTime )
{
buf.position( pos );
buf.get( scratchPad, i, howMuchToReadThisTime );
}
synchronized void fillWithZeros( int pos, int bytes )
{
buf.position( pos );
while ( bytes > 0 )
{
int howMuchToReadThisTime = min( bytes, zeroBuffer.length );
buf.put( zeroBuffer, 0, howMuchToReadThisTime );
bytes -= howMuchToReadThisTime;
}
buf.position( pos );
}
/**
* Checks if more space needs to be allocated.
*/
private void verifySize( int totalAmount )
{
if ( buf.capacity() >= totalAmount )
{
return;
}
// Double size each time, but after 1M only increase by 1M at a time, until required amount is reached.
int newSize = buf.capacity();
int sizeIndex = sizeIndexFor( newSize );
while ( newSize < totalAmount )
{
newSize += Math.min( newSize, 1024 * 1024 );
sizeIndex++;
}
int oldPosition = this.buf.position();
ByteBuffer buf = allocate( sizeIndex );
this.buf.position( 0 );
buf.put( this.buf );
this.buf = buf;
this.buf.position( oldPosition );
}
private static int sizeIndexFor( int capacity )
{
// Double size each time, but after 1M only increase by 1M at a time, until required amount is reached.
int sizeIndex = capacity / SIZES[SIZES.length - 1];
if (sizeIndex == 0) for ( ; sizeIndex < SIZES.length; sizeIndex++ )
{
if ( capacity == SIZES[sizeIndex] )
break;
}
else
{
sizeIndex += SIZES.length - 1;
}
return sizeIndex;
}
public void clear()
{
this.buf.clear();
}
void dump( OutputStream target, byte[] scratchPad, int size ) throws IOException
{
buf.position( 0 );
while ( size > 0 )
{
int read = min( size, scratchPad.length );
buf.get( scratchPad, 0, read );
size -= read;
target.write( scratchPad, 0, read );
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralFileSystemAbstraction.java
|
2,215
|
private static class EphemeralFileChannel extends FileChannel implements Positionable
{
final FileStillOpenException openedAt;
private final EphemeralFileData data;
private long position = 0;
EphemeralFileChannel( EphemeralFileData data, FileStillOpenException opened )
{
this.data = data;
this.openedAt = opened;
data.open( this );
}
@Override
public String toString()
{
return String.format( "%s[%s]", getClass().getSimpleName(), openedAt.filename );
}
@Override
public int read( ByteBuffer dst )
{
return data.read( this, dst );
}
@Override
public long read( ByteBuffer[] dsts, int offset, int length )
{
throw new UnsupportedOperationException();
}
@Override
public int write( ByteBuffer src ) throws IOException
{
return data.write( this, src );
}
@Override
public long write( ByteBuffer[] srcs, int offset, int length )
{
throw new UnsupportedOperationException();
}
@Override
public long position() throws IOException
{
return position;
}
@Override
public FileChannel position( long newPosition ) throws IOException
{
this.position = newPosition;
return this;
}
@Override
public long size() throws IOException
{
return data.size();
}
@Override
public FileChannel truncate( long size ) throws IOException
{
data.truncate( size );
return this;
}
@Override
public void force(boolean metaData)
{
// NO-OP
}
@Override
public long transferTo(long position, long count, WritableByteChannel target)
{
throw new UnsupportedOperationException();
}
@Override
public long transferFrom( ReadableByteChannel src, long position, long count ) throws IOException
{
long previousPos = position();
position( position );
try
{
long transferred = 0;
ByteBuffer intermediary = ByteBuffer.allocateDirect( 8096 );
while ( transferred < count )
{
intermediary.clear();
intermediary.limit( (int) min( intermediary.capacity(), count-transferred ) );
int read = src.read( intermediary );
if ( read == -1 )
break;
transferred += read;
intermediary.flip();
}
return transferred;
}
finally
{
position( previousPos );
}
}
@Override
public int read( ByteBuffer dst, long position ) throws IOException
{
return data.read( new LocalPosition( position ), dst );
}
@Override
public int write( ByteBuffer src, long position ) throws IOException
{
return data.write( new LocalPosition( position ), src );
}
@Override
public MappedByteBuffer map( FileChannel.MapMode mode, long position, long size ) throws IOException
{
throw new IOException("Not supported");
}
@Override
public java.nio.channels.FileLock lock( long position, long size, boolean shared ) throws IOException
{
synchronized ( data.channels )
{
if ( !data.lock() )
{
return null;
}
return new EphemeralFileLock( this, data );
}
}
@Override
public java.nio.channels.FileLock tryLock( long position, long size, boolean shared ) throws IOException
{
synchronized ( data.channels )
{
if ( !data.lock() )
{
throw new IOException( "Locked" );
}
return new EphemeralFileLock( this, data );
}
}
@Override
protected void implCloseChannel() throws IOException
{
data.close( this );
}
@Override
public long pos()
{
return position;
}
@Override
public void pos( long position )
{
this.position = position;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralFileSystemAbstraction.java
|
2,216
|
private static class ChainedMultipleExceptionsStrategy extends MultipleExceptionsStrategy
{
@Override
Throwable aggregate( List<Throwable> failures )
{
Throwable result = null;
for ( Throwable throwable : failures )
{
Throwable last = throwable;
for ( Throwable cause = last.getCause(); cause != null; cause = cause.getCause() )
{
last = cause;
}
last.initCause( result );
result = throwable;
}
return null;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_MultipleExceptionsStrategy.java
|
2,217
|
public class HTTP
{
private static final Builder BUILDER = new Builder().withHeaders( "Accept", "application/json" );
private static final Client CLIENT = new Client();
public static Builder withHeaders( Map<String, String> headers )
{
return BUILDER.withHeaders( headers );
}
public static Builder withHeaders( String... kvPairs )
{
return BUILDER.withHeaders( kvPairs );
}
public static Builder withBaseUri( String baseUri )
{
return BUILDER.withBaseUri( baseUri );
}
public static Response POST( String uri )
{
return BUILDER.POST( uri );
}
public static Response POST( String uri, Object payload )
{
return BUILDER.POST( uri, payload );
}
public static Response POST( String uri, RawPayload payload )
{
return BUILDER.POST( uri, payload );
}
public static Response PUT( String uri )
{
return BUILDER.PUT( uri );
}
public static Response PUT( String uri, Object payload )
{
return BUILDER.PUT( uri, payload );
}
public static Response PUT( String uri, RawPayload payload )
{
return BUILDER.PUT( uri, payload );
}
public static Response DELETE( String uri )
{
return BUILDER.DELETE( uri );
}
public static Response GET( String uri )
{
return BUILDER.GET( uri );
}
public static class Builder
{
private final Map<String, String> headers;
private final String baseUri;
private Builder()
{
this( Collections.<String, String>emptyMap(), "" );
}
private Builder( Map<String, String> headers, String baseUri )
{
this.baseUri = baseUri;
this.headers = unmodifiableMap( headers );
}
public Builder withHeaders( String... kvPairs )
{
return withHeaders( stringMap( kvPairs ) );
}
public Builder withHeaders( Map<String, String> newHeaders )
{
HashMap<String, String> combined = new HashMap<>();
combined.putAll( newHeaders );
combined.putAll( headers );
return new Builder( combined, baseUri );
}
public Builder withBaseUri( String baseUri )
{
return new Builder( headers, baseUri );
}
public Response POST( String uri )
{
return exec( "POST", uri );
}
public Response POST( String uri, Object payload )
{
return exec( "POST", uri, payload );
}
public Response POST( String uri, RawPayload payload )
{
return exec( "POST", uri, payload );
}
public Response PUT( String uri )
{
return exec( "PUT", uri );
}
public Response PUT( String uri, Object payload )
{
return exec( "PUT", uri, payload );
}
public Response PUT( String uri, RawPayload payload )
{
return exec( "PUT", uri, payload );
}
public Response DELETE( String uri )
{
return exec( "DELETE", uri );
}
public Response GET( String uri )
{
return exec( "GET", uri );
}
public Response exec( String method, String uri )
{
return new Response( CLIENT.handle( build().build( buildUri( uri ), method ) ) );
}
public Response exec( String method, String uri, Object payload )
{
String jsonPayload = payload instanceof RawPayload ? ((RawPayload) payload).get() : createJsonFrom(
payload );
ClientRequest.Builder lastBuilder = build().entity( jsonPayload, MediaType.APPLICATION_JSON_TYPE );
return new Response( CLIENT.handle( lastBuilder.build( buildUri( uri ), method ) ) );
}
private URI buildUri( String uri )
{
URI unprefixedUri = URI.create( uri );
if ( unprefixedUri.isAbsolute() )
{
return unprefixedUri;
}
else
{
return URI.create( baseUri + uri );
}
}
private ClientRequest.Builder build()
{
ClientRequest.Builder builder = ClientRequest.create();
for ( Map.Entry<String, String> header : headers.entrySet() )
{
builder = builder.header( header.getKey(), header.getValue() );
}
return builder;
}
}
/**
* Check some general validations that all REST responses should always pass.
*/
public static ClientResponse sanityCheck( ClientResponse response )
{
List<String> contentEncodings = response.getHeaders().get( "Content-Encoding" );
String contentEncoding;
if ( contentEncodings != null && (contentEncoding = singleOrNull( contentEncodings )) != null )
{
// Specifically, this is never used for character encoding.
contentEncoding = contentEncoding.toLowerCase();
assertThat( contentEncoding, anyOf(
containsString( "gzip" ),
containsString( "deflate" ) ) );
assertThat( contentEncoding, allOf(
not( containsString( "utf-8" ) ) ) );
}
return response;
}
public static class Response
{
private final ClientResponse response;
private final String entity;
public Response( ClientResponse response )
{
this.response = sanityCheck( response );
this.entity = response.getEntity( String.class );
}
public int status()
{
return response.getStatus();
}
public String location()
{
if ( response.getLocation() != null )
{
return response.getLocation().toString();
}
throw new RuntimeException( "The request did not contain a location header, " +
"unable to provide location. Status code was: " + status() );
}
@SuppressWarnings("unchecked")
public <T> T content()
{
try
{
return (T) JsonHelper.readJson( entity );
}
catch ( JsonParseException e )
{
throw new RuntimeException( "Unable to deserialize: " + entity, e );
}
}
public String rawContent()
{
return entity;
}
public String stringFromContent( String key ) throws JsonParseException
{
return get(key).asText();
}
public JsonNode get(String fieldName) throws JsonParseException
{
return JsonHelper.jsonNode( entity ).get( fieldName );
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append( "HTTP " ).append( response.getStatus() ).append( "\n" );
for ( Map.Entry<String, List<String>> header : response.getHeaders().entrySet() )
{
for ( String headerEntry : header.getValue() )
{
sb.append( header.getKey() + ": " ).append( headerEntry ).append( "\n" );
}
}
sb.append( "\n" );
sb.append( entity ).append( "\n" );
return sb.toString();
}
}
public static class RawPayload
{
private final String payload;
public static RawPayload rawPayload( String payload )
{
return new RawPayload( payload );
}
public static RawPayload quotedJson( String json )
{
return new RawPayload( json.replaceAll( "'", "\"" ) );
}
private RawPayload( String payload )
{
this.payload = payload;
}
public String get()
{
return payload;
}
}
}
| false
|
community_server_src_test_java_org_neo4j_test_server_HTTP.java
|
2,218
|
{
@Override
public Void call() throws Exception
{
ServerHolder.ensureNotRunning();
return null;
}
} );
| false
|
community_server_src_test_java_org_neo4j_test_server_ExclusiveServerTestBase.java
|
2,219
|
public class ExclusiveServerTestBase
{
@Rule
public TemporaryFolder folder = new TemporaryFolder();
@Rule
public Mute mute = muteAll();
@BeforeClass
public static final void ensureServerNotRunning() throws Exception
{
muteAll().call( new Callable<Void>()
{
@Override
public Void call() throws Exception
{
ServerHolder.ensureNotRunning();
return null;
}
} );
}
}
| false
|
community_server_src_test_java_org_neo4j_test_server_ExclusiveServerTestBase.java
|
2,220
|
public class EntityOutputFormat extends OutputFormat
{
private Representation representation;
public EntityOutputFormat( RepresentationFormat format, URI baseUri, ExtensionInjector extensions )
{
super( format, baseUri, extensions );
}
@Override
protected Response response( Response.ResponseBuilder response, Representation representation )
{
this.representation = representation;
return super.response( response, representation );
}
@SuppressWarnings( "unchecked" )
public Map<String, Object> getResultAsMap()
{
return (Map<String, Object>) serialize( representation );
}
public Representation getRepresentation()
{
return representation;
}
@SuppressWarnings( "unchecked" )
public List<Object> getResultAsList()
{
return (List<Object>) serialize( representation );
}
}
| false
|
community_server_src_test_java_org_neo4j_test_server_EntityOutputFormat.java
|
2,221
|
public class Properties implements Answer<Object>, Iterable<String>
{
public static Properties properties( Property... properties )
{
return new Properties( properties );
}
public static Properties properties( Map<String, Object> properties )
{
return new Properties( properties );
}
private final Map<String, Object> properties = new HashMap<>();
private Properties( Property[] properties )
{
for ( Property property : properties )
{
this.properties.put( property.key(), property.value() );
}
}
private Properties( Map<String, Object> properties )
{
this.properties.putAll( properties );
}
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
Object[] arguments = invocation.getArguments();
@SuppressWarnings("SuspiciousMethodCalls")
Object result = properties.get( arguments[0] );
if ( result == null )
{
if ( arguments.length == 2 )
{
return arguments[1];
}
else
{
throw new NotFoundException();
}
}
return result;
}
@Override
public Iterator<String> iterator()
{
return properties.keySet().iterator();
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_mocking_Properties.java
|
2,222
|
public class Link
{
public static Link link( Relationship relationship, Node node )
{
if ( relationship.getStartNode().getId() == node.getId() )
{
return new Link( node, relationship );
}
if ( relationship.getEndNode().getId() == node.getId() )
{
return new Link( relationship, node );
}
throw illegalArgument( "%s is neither the start node nor the end node of %s", node, relationship );
}
final Relationship relationship;
private final Node node;
private final boolean isStartNode;
private Link( Node node, Relationship relationship )
{
this.relationship = relationship;
this.node = node;
this.isStartNode = true;
}
private Link( Relationship relationship, Node node )
{
this.relationship = relationship;
this.node = node;
this.isStartNode = false;
}
public Node checkNode( Node node )
{
if ( isStartNode )
{
if ( node.getId() != relationship.getEndNode().getId() )
{
throw illegalArgument( "%s is not the end node of %s", node, relationship );
}
}
else
{
if ( node.getId() != relationship.getStartNode().getId() )
{
throw illegalArgument( "%s is not the start node of %s", node, relationship );
}
}
return this.node;
}
private static IllegalArgumentException illegalArgument( String message, Object... parameters )
{
return new IllegalArgumentException( String.format( message, parameters ) );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_mocking_Link.java
|
2,223
|
{
@Override
public Iterator<T> answer( InvocationOnMock invocation ) throws Throwable
{
return iterable.iterator();
}
};
| false
|
community_kernel_src_test_java_org_neo4j_test_mocking_GraphMock.java
|
2,224
|
public class GraphMock
{
public static Label[] labels( String... names )
{
Label[] labels = new Label[names.length];
for ( int i = 0; i < labels.length; i++ )
{
labels[i] = DynamicLabel.label( names[i] );
}
return labels;
}
public static Node node( long id, Label[] labels, Property... properties )
{
return mockNode( id, labels, properties( properties ) );
}
public static Node node( long id, Properties properties, String... labels )
{
return mockNode( id, labels( labels ), properties );
}
public static Relationship relationship( long id, Properties properties, Node start, String type, Node end )
{
return mockRelationship( id, start, type, end, properties );
}
public static Relationship relationship( long id, Node start, String type, Node end, Property... properties )
{
return mockRelationship( id, start, type, end, properties( properties ) );
}
public static Link link( Relationship relationship, Node node )
{
return Link.link( relationship, node );
}
public static Path path( Node node, Link... links )
{
List<Node> nodes = new ArrayList<>( links.length + 1 );
List<Relationship> relationships = new ArrayList<>( links.length );
List<PropertyContainer> mixed = new ArrayList<>( links.length * 2 + 1 );
nodes.add( node );
mixed.add( node );
Path path = mock( Path.class );
when( path.startNode() ).thenReturn( node );
Relationship last = null;
for ( Link link : links )
{
last = link.relationship;
relationships.add( last );
mixed.add( last );
node = link.checkNode( node );
nodes.add( node );
mixed.add( node );
}
when( path.endNode() ).thenReturn( node );
when( path.iterator() ).thenAnswer( withIteratorOf( mixed ) );
when( path.nodes() ).thenReturn( nodes );
when( path.relationships() ).thenReturn( relationships );
when( path.lastRelationship() ).thenReturn( last );
when( path.length() ).thenReturn( links.length );
when( path.reverseNodes() ).thenReturn( reverse( nodes ) );
when( path.reverseRelationships() ).thenReturn( reverse( relationships ) );
return path;
}
private static <T> Answer<Iterator<T>> withIteratorOf( final Iterable<T> iterable )
{
return new Answer<Iterator<T>>()
{
@Override
public Iterator<T> answer( InvocationOnMock invocation ) throws Throwable
{
return iterable.iterator();
}
};
}
private static Node mockNode( long id, Label[] labels, Properties properties )
{
Node node = mockPropertyContainer( Node.class, properties );
when( node.getId() ).thenReturn( id );
when( node.getLabels() ).thenReturn( asResourceIterable( asList( labels ) ) );
return node;
}
private static Relationship mockRelationship( long id, Node start, String type, Node end, Properties properties )
{
Relationship relationship = mockPropertyContainer( Relationship.class, properties );
when( relationship.getId() ).thenReturn( id );
when( relationship.getStartNode() ).thenReturn( start );
when( relationship.getEndNode() ).thenReturn( end );
when( relationship.getType() ).thenReturn( DynamicRelationshipType.withName( type ) );
return relationship;
}
private static <T extends PropertyContainer> T mockPropertyContainer( Class<T> type, Properties properties )
{
T container = mock( type );
when( container.getProperty( anyString() ) ).thenAnswer( properties );
when( container.getProperty( anyString(), any() ) ).thenAnswer( properties );
when( container.getPropertyKeys() ).thenReturn( properties );
return container;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_mocking_GraphMock.java
|
2,225
|
public abstract class MultipleExceptionsStrategy
{
public static void assertEmpty( List<Throwable> failures ) throws Throwable
{
if ( failures.isEmpty() ) return;
if ( failures.size() == 1 ) throw failures.get( 0 );
throw strategy.aggregate( failures );
}
public static void assertEmptyExceptions( List<? extends Exception> exceptions ) throws Exception
{
try
{
assertEmpty( unsafeCast(exceptions) );
}
catch ( Throwable e )
{
throw launderedException( Exception.class, e );
}
}
private static final MultipleExceptionsStrategy strategy;
static
{
MultipleExceptionsStrategy choice = new ChainedMultipleExceptionsStrategy();
String pkg = MultipleExceptionsStrategy.class.getPackage().getName();
ClassLoader loader = MultipleExceptionsStrategy.class.getClassLoader();
for ( String name : new String[] { "JUnitMultipleExceptions" } )
{
try
{
choice = (MultipleExceptionsStrategy) loader.loadClass( pkg + "." + name ).newInstance();
}
catch ( Throwable e )
{
continue;
}
break;
}
strategy = choice;
}
abstract Throwable aggregate( List<Throwable> failures );
MultipleExceptionsStrategy()
{
// subclasses live in this package
}
private static class ChainedMultipleExceptionsStrategy extends MultipleExceptionsStrategy
{
@Override
Throwable aggregate( List<Throwable> failures )
{
Throwable result = null;
for ( Throwable throwable : failures )
{
Throwable last = throwable;
for ( Throwable cause = last.getCause(); cause != null; cause = cause.getCause() )
{
last = cause;
}
last.initCause( result );
result = throwable;
}
return null;
}
}
@SuppressWarnings( "unchecked" )
private static List<Throwable> unsafeCast( List<?> exceptions )
{
return (List<Throwable>)exceptions;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_MultipleExceptionsStrategy.java
|
2,226
|
private static class EphemeralFileData
{
private static final ThreadLocal<byte[]> SCRATCH_PAD = new ThreadLocal<byte[]>()
{
@Override
protected byte[] initialValue()
{
return new byte[1024];
}
};
private final DynamicByteBuffer fileAsBuffer;
private final Collection<WeakReference<EphemeralFileChannel>> channels = new LinkedList<>();
private int size;
private int locked;
public EphemeralFileData()
{
this( new DynamicByteBuffer() );
}
private EphemeralFileData( DynamicByteBuffer data )
{
this.fileAsBuffer = data;
}
int read( Positionable fc, ByteBuffer dst )
{
int wanted = dst.limit();
int available = min(wanted, (int) (size() - fc.pos()));
if ( available == 0 ) return -1; // EOF
int pending = available;
// Read up until our internal size
byte[] scratchPad = SCRATCH_PAD.get();
while (pending > 0)
{
int howMuchToReadThisTime = min(pending, scratchPad.length);
long pos = fc.pos();
fileAsBuffer.get((int) pos, scratchPad, 0, howMuchToReadThisTime);
fc.pos( pos + howMuchToReadThisTime );
dst.put(scratchPad, 0, howMuchToReadThisTime);
pending -= howMuchToReadThisTime;
}
return available; // return how much data was read
}
int write( Positionable fc, ByteBuffer src )
{
int wanted = src.limit();
int pending = wanted;
byte[] scratchPad = SCRATCH_PAD.get();
while ( pending > 0 )
{
int howMuchToWriteThisTime = min( pending, scratchPad.length );
src.get( scratchPad, 0, howMuchToWriteThisTime );
long pos = fc.pos();
fileAsBuffer.put( (int) pos, scratchPad, 0, howMuchToWriteThisTime );
fc.pos( pos += howMuchToWriteThisTime );
pending -= howMuchToWriteThisTime;
}
synchronized ( fileAsBuffer )
{
// If we just made a jump in the file fill the rest of the gap with zeros
int newSize = max( size, (int) fc.pos() );
int intermediaryBytes = newSize - wanted - size;
if ( intermediaryBytes > 0 )
{
fileAsBuffer.fillWithZeros( size, intermediaryBytes );
}
size = newSize;
}
return wanted;
}
EphemeralFileData copy()
{
synchronized ( fileAsBuffer )
{
EphemeralFileData copy = new EphemeralFileData( fileAsBuffer.copy() );
copy.size = size;
return copy;
}
}
void open( EphemeralFileChannel channel )
{
synchronized ( channels )
{
channels.add( new WeakReference<>( channel ) );
}
}
void close( EphemeralFileChannel channel )
{
synchronized ( channels )
{
locked = 0; // Regular file systems seems to release all file locks when closed...
for ( Iterator<EphemeralFileChannel> iter = getOpenChannels(); iter.hasNext(); )
{
if ( iter.next() == channel )
{
iter.remove();
}
}
}
}
Iterator<EphemeralFileChannel> getOpenChannels()
{
final Iterator<WeakReference<EphemeralFileChannel>> refs = channels.iterator();
return new PrefetchingIterator<EphemeralFileChannel>()
{
@Override
protected EphemeralFileChannel fetchNextOrNull()
{
while ( refs.hasNext() )
{
EphemeralFileChannel channel = refs.next().get();
if ( channel != null ) return channel;
refs.remove();
}
return null;
}
@Override
public void remove()
{
refs.remove();
}
};
}
long size()
{
synchronized ( fileAsBuffer )
{
return size;
}
}
void truncate( long newSize )
{
synchronized ( fileAsBuffer )
{
this.size = (int) newSize;
}
}
boolean lock()
{
return locked == 0;
}
void dumpTo( OutputStream target ) throws IOException
{
byte[] scratchPad = SCRATCH_PAD.get();
synchronized ( fileAsBuffer )
{
fileAsBuffer.dump( target, scratchPad, size );
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralFileSystemAbstraction.java
|
2,227
|
class JUnitMultipleExceptions extends MultipleExceptionsStrategy
{
{
// Make sure that we can access the JUnit MultipleFailureException type
try
{
MultipleFailureException.assertEmpty( Collections.<Throwable>emptyList() );
}
catch ( Throwable e )
{
throw Exceptions.launderedException( e );
}
}
@Override
Throwable aggregate( List<Throwable> failures )
{
return new MultipleFailureException( failures );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_JUnitMultipleExceptions.java
|
2,228
|
public static class Factory implements IdGeneratorFactory
{
private final Map<IdType, IdGenerator> generators = new EnumMap<IdType, IdGenerator>( IdType.class );
@Override
public IdGenerator open( FileSystemAbstraction fs, File fileName, int grabSize, IdType idType, long highId )
{
IdGenerator generator = generators.get( idType );
if ( generator == null )
{
generator = new EphemeralIdGenerator( idType );
generators.put( idType, generator );
}
return generator;
}
@Override
public void create( FileSystemAbstraction fs, File fileName, long highId )
{
}
@Override
public IdGenerator get( IdType idType )
{
return generators.get( idType );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralIdGenerator.java
|
2,229
|
public class EphemeralIdGenerator implements IdGenerator
{
public static class Factory implements IdGeneratorFactory
{
private final Map<IdType, IdGenerator> generators = new EnumMap<IdType, IdGenerator>( IdType.class );
@Override
public IdGenerator open( FileSystemAbstraction fs, File fileName, int grabSize, IdType idType, long highId )
{
IdGenerator generator = generators.get( idType );
if ( generator == null )
{
generator = new EphemeralIdGenerator( idType );
generators.put( idType, generator );
}
return generator;
}
@Override
public void create( FileSystemAbstraction fs, File fileName, long highId )
{
}
@Override
public IdGenerator get( IdType idType )
{
return generators.get( idType );
}
}
private final AtomicLong nextId = new AtomicLong();
private final IdType idType;
private final Queue<Long> freeList;
private final AtomicInteger freedButNotReturnableIdCount = new AtomicInteger();
public EphemeralIdGenerator( IdType idType )
{
this.idType = idType;
this.freeList = idType != null && idType.allowAggressiveReuse() ? new ConcurrentLinkedQueue<Long>() : null;
}
@Override
public String toString()
{
return getClass().getSimpleName() + "[" + idType + "]";
}
@Override
public long nextId()
{
if ( freeList != null )
{
Long id = freeList.poll();
if ( id != null ) return id.longValue();
}
return nextId.getAndIncrement();
}
@Override
public IdRange nextIdBatch( int size )
{
throw new UnsupportedOperationException();
}
@Override
public void setHighId( long id )
{
nextId.set( id );
}
@Override
public long getHighId()
{
return nextId.get();
}
@Override
public void freeId( long id )
{
if (freeList != null) freeList.add( id );
else freedButNotReturnableIdCount.getAndIncrement();
}
@Override
public void close()
{
}
@Override
public long getNumberOfIdsInUse()
{
long result = freeList == null ? nextId.get() : nextId.get() - freeList.size();
return result-freedButNotReturnableIdCount.get();
}
@Override
public long getDefragCount()
{
return 0;
}
@Override
public void delete()
{
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralIdGenerator.java
|
2,230
|
static class LocalPosition implements Positionable
{
private long position;
public LocalPosition( long position )
{
this.position = position;
}
@Override
public long pos()
{
return position;
}
@Override
public void pos( long position )
{
this.position = position;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralFileSystemAbstraction.java
|
2,231
|
@SuppressWarnings( "serial" )
private static class FileStillOpenException extends Exception
{
private final String filename;
FileStillOpenException( String filename )
{
super( "File still open: [" + filename + "]" );
this.filename = filename;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralFileSystemAbstraction.java
|
2,232
|
private static class EphemeralFileLock extends java.nio.channels.FileLock
{
private EphemeralFileData file;
EphemeralFileLock(EphemeralFileChannel channel, EphemeralFileData file)
{
super(channel, 0, Long.MAX_VALUE, false);
this.file = file;
file.locked++;
}
@Override
public boolean isValid()
{
return file != null;
}
@Override
public void release() throws IOException
{
synchronized ( file.channels )
{
if ( file == null || file.locked == 0 )
{
return;
}
file.locked--;
file = null;
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralFileSystemAbstraction.java
|
2,233
|
{
@Override
protected EphemeralFileChannel fetchNextOrNull()
{
while ( refs.hasNext() )
{
EphemeralFileChannel channel = refs.next().get();
if ( channel != null ) return channel;
refs.remove();
}
return null;
}
@Override
public void remove()
{
refs.remove();
}
};
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralFileSystemAbstraction.java
|
2,234
|
{
@Override
protected byte[] initialValue()
{
return new byte[1024];
}
};
| false
|
community_kernel_src_test_java_org_neo4j_test_impl_EphemeralFileSystemAbstraction.java
|
2,235
|
private static class BatchInternalJettyServletResponse extends InternalJettyServletResponse {
private final ServletOutputStream output;
public BatchInternalJettyServletResponse(ServletOutputStream output) {
this.output = output;
}
@Override
public ServletOutputStream getOutputStream() throws IOException {
return output;
}
@Override
public PrintWriter getWriter() throws IOException {
return new PrintWriter( new OutputStreamWriter( output, "UTF-8") );
}
}
| false
|
community_server_src_main_java_org_neo4j_server_rest_web_StreamingBatchOperations.java
|
2,236
|
public class StreamingBatchOperations extends BatchOperations
{
private static final Logger LOGGER = Log.getLogger(StreamingBatchOperations.class);
private StreamingBatchOperationResults results;
public StreamingBatchOperations( WebServer webServer )
{
super( webServer );
}
public void readAndExecuteOperations( UriInfo uriInfo, HttpHeaders httpHeaders, InputStream body, ServletOutputStream output ) throws IOException, ServletException {
results = new StreamingBatchOperationResults(jsonFactory.createJsonGenerator(output),output);
Map<Integer, String> locations = results.getLocations();
parseAndPerform( uriInfo, httpHeaders, body, locations );
results.close();
}
/*
[{"from":"/node","body":{"extensions":{},"paged_traverse":"http://localhost:7474/db/data/node/1/paged/traverse/{returnType}{?pageSize,leaseTime}","outgoing_relationships":"http://localhost:7474/db/data/node/1/relationships/out","traverse":"http://localhost:7474/db/data/node/1/traverse/{returnType}","all_typed_relationships":"http://localhost:7474/db/data/node/1/relationships/all/{-list|&|types}","property":"http://localhost:7474/db/data/node/1/properties/{key}","all_relationships":"http://localhost:7474/db/data/node/1/relationships/all","self":"http://localhost:7474/db/data/node/1","properties":"http://localhost:7474/db/data/node/1/properties","outgoing_typed_relationships":"http://localhost:7474/db/data/node/1/relationships/out/{-list|&|types}","incoming_relationships":"http://localhost:7474/db/data/node/1/relationships/in","incoming_typed_relationships":"http://localhost:7474/db/data/node/1/relationships/in/{-list|&|types}","create_relationship":"http://localhost:7474/db/data/node/1/relationships","data":{"age":"1"}},"location":"http://localhost:7474/db/data/node/1","status":201},{"from":"/node","body":{"message":"java.util.ArrayList cannot be cast to java.util.Map","exception":"org.neo4j.server.rest.repr.BadInputException: java.util.ArrayList cannot be cast to java.util.Map","stacktrace":["org.neo4j.server.rest.repr.formats.JsonFormat.readMap(JsonFormat.java:92)","org.neo4j.server.rest.web.RestfulGraphDatabase.createNode(RestfulGraphDatabase.java:195)","sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)","sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)","sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)","java.lang.reflect.Method.invoke(Method.java:597)","com.sun.jersey.spi.container.JavaMethodInvokerFactory$1.invoke(JavaMethodInvokerFactory.java:60)","com.sun.jersey.server.impl.model.method.dispatch.AbstractResourceMethodDispatchProvider$ResponseOutInvoker._dispatch(AbstractResourceMethodDispatchProvider.java:205)","com.sun.jersey.server.impl.model.method.dispatch.ResourceJavaMethodDispatcher.dispatch(ResourceJavaMethodDispatcher.java:75)","com.sun.jersey.server.impl.uri.rules.HttpMethodRule.accept(HttpMethodRule.java:288)","com.sun.jersey.server.impl.uri.rules.RightHandPathRule.accept(RightHandPathRule.java:147)","com.sun.jersey.server.impl.uri.rules.ResourceClassRule.accept(ResourceClassRule.java:108)","com.sun.jersey.server.impl.uri.rules.RightHandPathRule.accept(RightHandPathRule.java:147)","com.sun.jersey.server.impl.uri.rules.RootResourceClassesRule.accept(RootResourceClassesRule.java:84)","com.sun.jersey.server.impl.application.WebApplicationImpl._handleRequest(WebApplicationImpl.java:1469)","com.sun.jersey.server.impl.application.WebApplicationImpl._handleRequest(WebApplicationImpl.java:1400)","com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1349)","com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1339)","com.sun.jersey.spi.container.servlet.WebComponent.service(WebComponent.java:416)","com.sun.jersey.spi.container.servlet.ServletContainer.service(ServletContainer.java:537)","com.sun.jersey.spi.container.servlet.ServletContainer.service(ServletContainer.java:699)","javax.servlet.http.HttpServlet.service(HttpServlet.java:820)","org.mortbay.jetty.servlet.ServletHolder.handle(ServletHolder.java:511)","org.mortbay.jetty.servlet.ServletHandler.handle(ServletHandler.java:390)","org.mortbay.jetty.servlet.SessionHandler.handle(SessionHandler.java:182)","org.mortbay.jetty.handler.ContextHandler.handle(ContextHandler.java:765)","org.mortbay.jetty.handler.HandlerCollection.handle(HandlerCollection.java:114)","org.mortbay.jetty.handler.HandlerWrapper.handle(HandlerWrapper.java:152)","org.neo4j.server.web.Jetty6WebServer.invokeDirectly(Jetty6WebServer.java:201)","org.neo4j.server.rest.web.StreamingBatchOperations.invoke(StreamingBatchOperations.java:62)","org.neo4j.server.rest.batch.BatchOperations.performRequest(BatchOperations.java:179)","org.neo4j.server.rest.batch.BatchOperations.parseAndPerform(BatchOperations.java:150)","org.neo4j.server.rest.web.StreamingBatchOperations.readAndExecuteOperations(StreamingBatchOperations.java:52)","org.neo4j.server.rest.web.BatchOperationService$1.write(BatchOperationService.java:88)","com.sun.jersey.core.impl.provider.entity.StreamingOutputProvider.writeTo(StreamingOutputProvider.java:71)","com.sun.jersey.core.impl.provider.entity.StreamingOutputProvider.writeTo(StreamingOutputProvider.java:57)","com.sun.jersey.spi.container.ContainerResponse.write(ContainerResponse.java:306)","com.sun.jersey.server.impl.application.WebApplicationImpl._handleRequest(WebApplicationImpl.java:1437)","com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1349)","com.sun.jersey.server.impl.application.WebApplicationImpl.handleRequest(WebApplicationImpl.java:1339)","com.sun.jersey.spi.container.servlet.WebComponent.service(WebComponent.java:416)","com.sun.jersey.spi.container.servlet.ServletContainer.service(ServletContainer.java:537)","com.sun.jersey.spi.container.servlet.ServletContainer.service(ServletContainer.java:699)","javax.servlet.http.HttpServlet.service(HttpServlet.java:820)","org.mortbay.jetty.servlet.ServletHolder.handle(ServletHolder.java:511)","org.mortbay.jetty.servlet.ServletHandler.handle(ServletHandler.java:390)","org.mortbay.jetty.servlet.SessionHandler.handle(SessionHandler.java:182)","org.mortbay.jetty.handler.ContextHandler.handle(ContextHandler.java:765)","org.mortbay.jetty.handler.HandlerCollection.handle(HandlerCollection.java:114)","org.mortbay.jetty.handler.HandlerWrapper.handle(HandlerWrapper.java:152)","org.mortbay.jetty.Server.handle(Server.java:322)","org.mortbay.jetty.HttpConnection.handleRequest(HttpConnection.java:542)","org.mortbay.jetty.HttpConnection$RequestHandler.content(HttpConnection.java:943)","org.mortbay.jetty.HttpParser.parseNext(HttpParser.java:756)","org.mortbay.jetty.HttpParser.parseAvailable(HttpParser.java:218)","org.mortbay.jetty.HttpConnection.handle(HttpConnection.java:404)","org.mortbay.io.nio.SelectChannelEndPoint.run(SelectChannelEndPoint.java:410)","org.mortbay.thread.QueuedThreadPool$PoolThread.run(QueuedThreadPool.java:582)"]}null,"status":400}]
*/
@Override
protected void invoke(String method, String path, String body, Integer id, URI targetUri, InternalJettyServletRequest req, InternalJettyServletResponse res ) throws IOException, ServletException
{
results.startOperation(path,id);
try {
res = new BatchInternalJettyServletResponse(results.getServletOutputStream());
webServer.invokeDirectly(targetUri.getPath(), req, res);
} catch(Exception e) {
LOGGER.warn( e );
results.writeError( 500, e.getMessage() );
throw new BatchOperationFailedException(500, e.getMessage(),e );
}
final int status = res.getStatus();
if (is2XXStatusCode(status))
{
results.addOperationResult(status,id,res.getHeader("Location"));
}
else
{
final String message = "Error " + status + " executing batch operation: " + ((id!=null) ? id + ". ":"") + method + " " + path + " " + body;
results.writeError( status, res.getReason() );
throw new BatchOperationFailedException(status, message, new OperationFailureException(res.getReason()) );
}
}
protected void addHeaders(final InternalJettyServletRequest res,
final HttpHeaders httpHeaders)
{
super.addHeaders( res,httpHeaders );
res.addHeader(StreamingJsonFormat.STREAM_HEADER,"true");
}
private static class BatchInternalJettyServletResponse extends InternalJettyServletResponse {
private final ServletOutputStream output;
public BatchInternalJettyServletResponse(ServletOutputStream output) {
this.output = output;
}
@Override
public ServletOutputStream getOutputStream() throws IOException {
return output;
}
@Override
public PrintWriter getWriter() throws IOException {
return new PrintWriter( new OutputStreamWriter( output, "UTF-8") );
}
}
}
| false
|
community_server_src_main_java_org_neo4j_server_rest_web_StreamingBatchOperations.java
|
2,237
|
public class RestfulGraphDatabaseTest
{
private static final String NODE_AUTO_INDEX = "node_auto_index";
private static final String RELATIONSHIP_AUTO_INDEX = "relationship_auto_index";
private static final String BASE_URI = "http://neo4j.org/";
private static final String NODE_SUBPATH = "node/";
private static RestfulGraphDatabase service;
private static Database database;
private static GraphDbHelper helper;
private static EntityOutputFormat output;
private static LeaseManager leaseManager;
private static final ForceMode FORCE = ForceMode.forced;
private static AbstractGraphDatabase graph;
@BeforeClass
public static void doBefore() throws IOException
{
graph = (AbstractGraphDatabase)new TestGraphDatabaseFactory().newImpermanentDatabase();
database = new WrappedDatabase(graph);
helper = new GraphDbHelper( database );
output = new EntityOutputFormat( new JsonFormat(), URI.create( BASE_URI ), null );
leaseManager = new LeaseManager( new FakeClock() );
service = new RestfulGraphDatabase( new JsonFormat(), output,
new DatabaseActions( leaseManager, ForceMode.forced, true, database.getGraph() ) );
service = new TransactionWrappingRestfulGraphDatabase( graph, service );
}
@Before
public void deleteAllIndexes() throws JsonParseException
{
for ( String name : helper.getNodeIndexes() )
{
if ( NODE_AUTO_INDEX.equals( name ) )
{
stopAutoIndexAllPropertiesAndDisableAutoIndex( "node" );
}
else
{
service.deleteNodeIndex( FORCE, name );
}
}
for ( String name : helper.getRelationshipIndexes() )
{
if ( RELATIONSHIP_AUTO_INDEX.equals( name ) )
{
stopAutoIndexAllPropertiesAndDisableAutoIndex( "relationship" );
}
else
{
service.deleteRelationshipIndex( FORCE, name );
}
}
}
protected void stopAutoIndexAllPropertiesAndDisableAutoIndex( String type )
throws JsonParseException
{
Response response = service.getAutoIndexedProperties( type );
List<String> properties = entityAsList( response );
for ( String property : properties )
{
service.stopAutoIndexingProperty( type, property );
}
service.setAutoIndexerEnabled( type, "false" );
}
@AfterClass
public static void shutdownDatabase() throws Throwable
{
graph.shutdown();
}
private static String entityAsString( Response response )
{
byte[] bytes = (byte[]) response.getEntity();
try
{
return new String( bytes, "UTF-8" );
}
catch ( UnsupportedEncodingException e )
{
throw new RuntimeException( "Could not decode UTF-8", e );
}
}
@SuppressWarnings("unchecked")
private static List<String> entityAsList( Response response )
throws JsonParseException
{
String entity = entityAsString( response );
return (List<String>) JsonHelper.readJson( entity );
}
@Test
public void shouldFailGracefullyWhenViolatingConstraintOnPropertyUpdate() throws Exception
{
Response response = service.createPropertyUniquenessConstraint( "Person", "{\"property_keys\":[\"name\"]}" );
assertEquals( 200, response.getStatus() );
createPerson( "Fred" );
String wilma = createPerson( "Wilma" );
assertEquals( 409, service.setAllNodeProperties( FORCE, parseLong( wilma ), "{\"name\":\"Fred\"}" ).getStatus() );
assertEquals( 409, service.setNodeProperty( FORCE, parseLong( wilma ), "name", "\"Fred\"" ).getStatus() );
}
private String createPerson( final String name ) throws JsonParseException
{
Response response = service.createNode( FORCE, "{\"name\" : \"" + name + "\"}" );
assertEquals( 201, response.getStatus() );
String self = (String) JsonHelper.jsonToMap( entityAsString( response ) ).get( "self" );
String nodeId = self.substring( self.indexOf( NODE_SUBPATH ) + NODE_SUBPATH.length() );
response = service.addNodeLabel( FORCE, parseLong( nodeId ), "\"Person\"" );
assertEquals( 204, response.getStatus() );
return nodeId;
}
@Test
public void shouldRespondWith201LocationHeaderAndNodeRepresentationInJSONWhenEmptyNodeCreated() throws Exception
{
Response response = service.createNode( FORCE, null );
assertEquals( 201, response.getStatus() );
assertNotNull( response.getMetadata()
.get( "Location" )
.get( 0 ) );
checkContentTypeCharsetUtf8(response);
String json = entityAsString( response );
Map<String, Object> map = JsonHelper.jsonToMap( json );
assertNotNull( map );
assertTrue( map.containsKey( "self" ) );
}
@Test
public void shouldRespondWith201LocationHeaderAndNodeRepresentationInJSONWhenPopulatedNodeCreated()
throws Exception
{
Response response = service.createNode( FORCE, "{\"foo\" : \"bar\"}" );
assertEquals( 201, response.getStatus() );
assertNotNull( response.getMetadata()
.get( "Location" )
.get( 0 ) );
checkContentTypeCharsetUtf8(response);
String json = entityAsString( response );
Map<String, Object> map = JsonHelper.jsonToMap( json );
assertNotNull( map );
assertTrue( map.containsKey( "self" ) );
@SuppressWarnings("unchecked") Map<String, Object> data = (Map<String, Object>) map.get( "data" );
assertEquals( "bar", data.get( "foo" ) );
}
@Test
@SuppressWarnings("unchecked")
public void shouldRespondWith201LocationHeaderAndNodeRepresentationInJSONWhenPopulatedNodeCreatedWithArrays()
throws Exception
{
Response response = service.createNode( FORCE, "{\"foo\" : [\"bar\", \"baz\"] }" );
assertEquals( 201, response.getStatus() );
assertNotNull( response.getMetadata()
.get( "Location" )
.get( 0 ) );
String json = entityAsString( response );
Map<String, Object> map = JsonHelper.jsonToMap( json );
assertNotNull( map );
Map<String, Object> data = (Map<String, Object>) map.get( "data" );
List<String> foo = (List<String>) data.get( "foo" );
assertNotNull( foo );
assertEquals( 2, foo.size() );
}
@Test
public void shouldRespondWith400WhenNodeCreatedWithUnsupportedPropertyData()
{
Response response = service.createNode( FORCE, "{\"foo\" : {\"bar\" : \"baz\"}}" );
assertEquals( 400, response.getStatus() );
}
@Test
public void shouldRespondWith400WhenNodeCreatedWithInvalidJSON()
{
Response response = service.createNode( FORCE, "this:::isNot::JSON}" );
assertEquals( 400, response.getStatus() );
}
@Test
public void shouldRespondWith200AndNodeRepresentationInJSONWhenNodeRequested() throws Exception
{
Response response = service.getNode( helper.createNode() );
assertEquals( 200, response.getStatus() );
String json = entityAsString( response );
Map<String, Object> map = JsonHelper.jsonToMap( json );
assertNotNull( map );
assertTrue( map.containsKey( "self" ) );
}
@Test
public void shouldRespondWith404WhenRequestedNodeDoesNotExist() throws Exception
{
Response response = service.getNode( 9000000000000L );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith204AfterSettingPropertiesOnExistingNode() throws Exception
{
Response response = service.setAllNodeProperties( FORCE, helper.createNode(),
"{\"foo\" : \"bar\", \"a-boolean\": true, \"boolean-array\": [true, false, false]}" );
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldRespondWith404WhenSettingPropertiesOnNodeThatDoesNotExist() throws Exception
{
Response response = service.setAllNodeProperties( FORCE, 9000000000000L, "{\"foo\" : \"bar\"}" );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith400WhenTransferringCorruptJsonPayload() throws Exception
{
Response response = service.setAllNodeProperties( FORCE, helper.createNode(),
"{\"foo\" : bad-json-here \"bar\"}" );
assertEquals( 400, response.getStatus() );
}
@Test
public void shouldRespondWith400WhenTransferringIncompatibleJsonPayload() throws Exception
{
Response response = service.setAllNodeProperties( FORCE, helper.createNode(),
"{\"foo\" : {\"bar\" : \"baz\"}}" );
assertEquals( 400, response.getStatus() );
}
@Test
public void shouldRespondWith200ForGetNodeProperties() throws Exception
{
long nodeId = helper.createNode();
Map<String, Object> properties = new HashMap<String, Object>();
properties.put( "foo", "bar" );
helper.setNodeProperties( nodeId, properties );
Response response = service.getAllNodeProperties( nodeId );
assertEquals( 200, response.getStatus() );
checkContentTypeCharsetUtf8(response);
}
@Test
public void shouldRespondWith204ForGetNoNodeProperties() throws Exception
{
long nodeId = helper.createNode();
Response response = service.getAllNodeProperties( nodeId );
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldGetPropertiesForGetNodeProperties() throws Exception
{
long nodeId = helper.createNode();
Map<String, Object> properties = new HashMap<String, Object>();
properties.put( "foo", "bar" );
properties.put( "number", 15 );
properties.put( "double", 15.7 );
helper.setNodeProperties( nodeId, properties );
Response response = service.getAllNodeProperties( nodeId );
String jsonBody = entityAsString( response );
Map<String, Object> readProperties = JsonHelper.jsonToMap( jsonBody );
assertEquals( properties, readProperties );
}
@Test
public void shouldRespondWith204OnSuccessfulDelete()
{
long id = helper.createNode();
Response response = service.deleteNode( FORCE, id );
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldRespondWith409IfNodeCannotBeDeleted()
{
long id = helper.createNode();
helper.createRelationship( "LOVES", id, helper.createNode() );
Response response = service.deleteNode( FORCE, id );
assertEquals( 409, response.getStatus() );
}
@Test
public void shouldRespondWith404IfNodeToBeDeletedDoesNotExist()
{
long nonExistentId = 999999;
Response response = service.deleteNode( FORCE, nonExistentId );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith204ForSetNodeProperty()
{
long nodeId = helper.createNode();
String key = "foo";
String json = "\"bar\"";
Response response = service.setNodeProperty( FORCE, nodeId, key, json );
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldSetRightValueForSetNodeProperty()
{
long nodeId = helper.createNode();
String key = "foo";
Object value = "bar";
String json = "\"" + value + "\"";
service.setNodeProperty( FORCE, nodeId, key, json );
Map<String, Object> readProperties = helper.getNodeProperties( nodeId );
assertEquals( Collections.singletonMap( key, value ), readProperties );
}
@Test
public void shouldRespondWith404ForSetNodePropertyOnNonExistingNode()
{
String key = "foo";
String json = "\"bar\"";
Response response = service.setNodeProperty( FORCE, 999999, key, json );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith400ForSetNodePropertyWithInvalidJson()
{
String key = "foo";
String json = "{invalid json";
Response response = service.setNodeProperty( FORCE, 999999, key, json );
assertEquals( 400, response.getStatus() );
}
@Test
public void shouldRespondWith404ForGetNonExistentNodeProperty()
{
long nodeId = helper.createNode();
Response response = service.getNodeProperty( FORCE, nodeId, "foo" );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith404ForGetNodePropertyOnNonExistentNode()
{
long nodeId = 999999;
Response response = service.getNodeProperty( FORCE, nodeId, "foo" );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith200ForGetNodeProperty()
{
long nodeId = helper.createNode();
String key = "foo";
Object value = "bar";
helper.setNodeProperties( nodeId, Collections.singletonMap( key, value ) );
Response response = service.getNodeProperty( FORCE, nodeId, "foo" );
assertEquals( 200, response.getStatus() );
checkContentTypeCharsetUtf8(response);
}
@Test
public void shouldReturnCorrectValueForGetNodeProperty() throws Exception
{
long nodeId = helper.createNode();
String key = "foo";
Object value = "bar";
helper.setNodeProperties( nodeId, Collections.singletonMap( key, value ) );
Response response = service.getNodeProperty( FORCE, nodeId, "foo" );
assertEquals( JsonHelper.createJsonFrom( value ), entityAsString( response ) );
}
@Test
public void shouldRespondWith201AndLocationWhenRelationshipIsCreatedWithoutProperties()
{
long startNode = helper.createNode();
long endNode = helper.createNode();
Response response = service.createRelationship( FORCE, startNode, "{\"to\" : \"" + BASE_URI + endNode
+ "\", \"type\" : \"LOVES\"}" );
assertEquals( 201, response.getStatus() );
assertNotNull( response.getMetadata()
.get( "Location" )
.get( 0 ) );
}
@Test
public void shouldRespondWith201AndLocationWhenRelationshipIsCreatedWithProperties()
{
long startNode = helper.createNode();
long endNode = helper.createNode();
Response response = service.createRelationship( FORCE, startNode,
"{\"to\" : \"" + BASE_URI + endNode + "\", \"type\" : \"LOVES\", " +
"\"properties\" : {\"foo\" : \"bar\"}}" );
assertEquals( 201, response.getStatus() );
assertNotNull( response.getMetadata()
.get( "Location" )
.get( 0 ) );
}
@Test
public void shouldReturnRelationshipRepresentationWhenCreatingRelationship() throws Exception
{
long startNode = helper.createNode();
long endNode = helper.createNode();
Response response = service.createRelationship( FORCE, startNode,
"{\"to\" : \"" + BASE_URI + endNode + "\", \"type\" : \"LOVES\", \"data\" : {\"foo\" : \"bar\"}}" );
Map<String, Object> map = JsonHelper.jsonToMap( entityAsString( response ) );
assertNotNull( map );
assertTrue( map.containsKey( "self" ) );
checkContentTypeCharsetUtf8(response);
@SuppressWarnings("unchecked") Map<String, Object> data = (Map<String, Object>) map.get( "data" );
assertEquals( "bar", data.get( "foo" ) );
}
@Test
public void shouldRespondWith404WhenTryingToCreateRelationshipFromNonExistentNode()
{
long nodeId = helper.createNode();
Response response = service.createRelationship( FORCE, nodeId * 1000, "{\"to\" : \"" + BASE_URI + nodeId
+ "\", \"type\" : \"LOVES\"}" );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith400WhenTryingToCreateRelationshipToNonExistentNode()
{
long nodeId = helper.createNode();
Response response = service.createRelationship( FORCE, nodeId, "{\"to\" : \"" + BASE_URI + (nodeId * 1000)
+ "\", \"type\" : \"LOVES\"}" );
assertEquals( 400, response.getStatus() );
}
@Test
public void shouldRespondWith201WhenTryingToCreateRelationshipBackToSelf()
{
long nodeId = helper.createNode();
Response response = service.createRelationship( FORCE, nodeId, "{\"to\" : \"" + BASE_URI + nodeId
+ "\", \"type\" : \"LOVES\"}" );
assertEquals( 201, response.getStatus() );
}
@Test
public void shouldRespondWith400WhenTryingToCreateRelationshipWithBadJson()
{
long startNode = helper.createNode();
long endNode = helper.createNode();
Response response = service.createRelationship( FORCE, startNode, "{\"to\" : \"" + BASE_URI + endNode
+ "\", \"type\" ***and junk*** : \"LOVES\"}" );
assertEquals( 400, response.getStatus() );
}
@Test
public void shouldRespondWith400WhenTryingToCreateRelationshipWithUnsupportedProperties()
{
long startNode = helper.createNode();
long endNode = helper.createNode();
Response response = service.createRelationship( FORCE, startNode,
"{\"to\" : \"" + BASE_URI + endNode
+ "\", \"type\" : \"LOVES\", \"data\" : {\"foo\" : {\"bar\" : \"baz\"}}}" );
assertEquals( 400, response.getStatus() );
}
@Test
public void shouldRespondWith204ForRemoveNodeProperties()
{
long nodeId = helper.createNode();
Map<String, Object> properties = new HashMap<String, Object>();
properties.put( "foo", "bar" );
properties.put( "number", 15 );
helper.setNodeProperties( nodeId, properties );
Response response = service.deleteAllNodeProperties( FORCE, nodeId );
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldBeAbleToRemoveNodeProperties()
{
long nodeId = helper.createNode();
Map<String, Object> properties = new HashMap<String, Object>();
properties.put( "foo", "bar" );
properties.put( "number", 15 );
helper.setNodeProperties( nodeId, properties );
service.deleteAllNodeProperties( FORCE, nodeId );
assertEquals( true, helper.getNodeProperties( nodeId )
.isEmpty() );
}
@Test
public void shouldRespondWith404ForRemoveNodePropertiesForNonExistingNode()
{
long nodeId = 999999;
Response response = service.deleteAllNodeProperties( FORCE, nodeId );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldBeAbleToRemoveNodeProperty()
{
long nodeId = helper.createNode();
Map<String, Object> properties = new HashMap<String, Object>();
properties.put( "foo", "bar" );
properties.put( "number", 15 );
helper.setNodeProperties( nodeId, properties );
service.deleteNodeProperty( FORCE, nodeId, "foo" );
assertEquals( Collections.singletonMap( "number", (Object) 15 ),
helper.getNodeProperties( nodeId ) );
}
@Test
public void shouldGet404WhenRemovingNonExistingProperty()
{
long nodeId = helper.createNode();
Map<String, Object> properties = new HashMap<String, Object>();
properties.put( "foo", "bar" );
properties.put( "number", 15 );
helper.setNodeProperties( nodeId, properties );
Response response = service.deleteNodeProperty( FORCE, nodeId, "baz" );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldGet404WhenRemovingPropertyFromNonExistingNode()
{
long nodeId = 999999;
Response response = service.deleteNodeProperty( FORCE, nodeId, "foo" );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldGet200WhenRetrievingARelationshipFromANode()
{
long relationshipId = helper.createRelationship( "BEATS" );
Response response = service.getRelationship( relationshipId );
assertEquals( 200, response.getStatus() );
checkContentTypeCharsetUtf8(response);
}
@Test
public void shouldGet404WhenRetrievingRelationshipThatDoesNotExist()
{
Response response = service.getRelationship( 999999 );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith200AndDataForGetRelationshipProperties() throws Exception
{
long relationshipId = helper.createRelationship( "knows" );
Map<String, Object> properties = new HashMap<String, Object>();
properties.put( "foo", "bar" );
helper.setRelationshipProperties( relationshipId, properties );
Response response = service.getAllRelationshipProperties( relationshipId );
assertEquals( 200, response.getStatus() );
checkContentTypeCharsetUtf8(response);
Map<String, Object> readProperties = JsonHelper.jsonToMap( entityAsString( response ) );
assertEquals( properties, readProperties );
}
@Test
public void shouldRespondWith204ForGetNoRelationshipProperties()
{
long relationshipId = helper.createRelationship( "knows" );
Response response = service.getAllRelationshipProperties( relationshipId );
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldGet200WhenSuccessfullyRetrievedPropertyOnRelationship()
throws Exception
{
long relationshipId = helper.createRelationship( "knows" );
Map<String, Object> properties = new HashMap<String, Object>();
properties.put( "some-key", "some-value" );
helper.setRelationshipProperties( relationshipId, properties );
Response response = service.getRelationshipProperty( relationshipId, "some-key" );
assertEquals( 200, response.getStatus() );
assertEquals( "some-value", JsonHelper.jsonToSingleValue( entityAsString( response ) ) );
checkContentTypeCharsetUtf8(response);
}
@Test
public void shouldGet404WhenCannotResolveAPropertyOnRelationship()
{
long relationshipId = helper.createRelationship( "knows" );
Response response = service.getRelationshipProperty( relationshipId, "some-key" );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldGet204WhenRemovingARelationship()
{
long relationshipId = helper.createRelationship( "KNOWS" );
Response response = service.deleteRelationship( FORCE, relationshipId );
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldGet404WhenRemovingNonExistentRelationship()
{
long relationshipId = helper.createRelationship( "KNOWS" );
Response response = service.deleteRelationship( FORCE, relationshipId + 1000 );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith200AndListOfRelationshipRepresentationsWhenGettingRelationshipsForANode()
throws Exception
{
long nodeId = helper.createNode();
helper.createRelationship( "LIKES", nodeId, helper.createNode() );
helper.createRelationship( "LIKES", helper.createNode(), nodeId );
helper.createRelationship( "HATES", nodeId, helper.createNode() );
Response response = service.getNodeRelationships( nodeId, RelationshipDirection.all,
new AmpersandSeparatedCollection( "" ) );
assertEquals( 200, response.getStatus() );
checkContentTypeCharsetUtf8(response);
verifyRelReps( 3, entityAsString( response ) );
response = service.getNodeRelationships( nodeId, RelationshipDirection.in,
new AmpersandSeparatedCollection( "" ) );
assertEquals( 200, response.getStatus() );
verifyRelReps( 1, entityAsString( response ) );
response = service.getNodeRelationships( nodeId, RelationshipDirection.out, new AmpersandSeparatedCollection(
"" ) );
assertEquals( 200, response.getStatus() );
verifyRelReps( 2, entityAsString( response ) );
response = service.getNodeRelationships( nodeId, RelationshipDirection.out, new AmpersandSeparatedCollection(
"LIKES&HATES" ) );
assertEquals( 200, response.getStatus() );
verifyRelReps( 2, entityAsString( response ) );
response = service.getNodeRelationships( nodeId, RelationshipDirection.all, new AmpersandSeparatedCollection(
"LIKES" ) );
assertEquals( 200, response.getStatus() );
verifyRelReps( 2, entityAsString( response ) );
}
@Test
public void shouldNotReturnDuplicatesIfSameTypeSpecifiedMoreThanOnce() throws Exception
{
long nodeId = helper.createNode();
helper.createRelationship( "LIKES", nodeId, helper.createNode() );
Response response = service.getNodeRelationships( nodeId, RelationshipDirection.all,
new AmpersandSeparatedCollection( "LIKES&LIKES" ) );
Collection<?> array = (Collection<?>) JsonHelper.jsonToSingleValue( entityAsString( response ) );
assertEquals( 1, array.size() );
}
private void verifyRelReps( int expectedSize, String entity ) throws JsonParseException
{
List<Map<String, Object>> relreps = JsonHelper.jsonToList( entity );
assertEquals( expectedSize, relreps.size() );
for ( Map<String, Object> relrep : relreps )
{
RelationshipRepresentationTest.verifySerialisation( relrep );
}
}
@Test
public void
shouldRespondWith200AndEmptyListOfRelationshipRepresentationsWhenGettingRelationshipsForANodeWithoutRelationships()
throws Exception
{
long nodeId = helper.createNode();
Response response = service.getNodeRelationships( nodeId, RelationshipDirection.all,
new AmpersandSeparatedCollection( "" ) );
assertEquals( 200, response.getStatus() );
verifyRelReps( 0, entityAsString( response ) );
checkContentTypeCharsetUtf8(response);
}
@Test
public void shouldRespondWith404WhenGettingIncomingRelationshipsForNonExistingNode()
{
Response response = service.getNodeRelationships( 999999, RelationshipDirection.all,
new AmpersandSeparatedCollection( "" ) );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith204AndSetCorrectDataWhenSettingRelationshipProperties()
{
long relationshipId = helper.createRelationship( "KNOWS" );
String json = "{\"name\": \"Mattias\", \"age\": 30}";
Response response = service.setAllRelationshipProperties( FORCE, relationshipId, json );
assertEquals( 204, response.getStatus() );
Map<String, Object> setProperties = new HashMap<String, Object>();
setProperties.put( "name", "Mattias" );
setProperties.put( "age", 30 );
assertEquals( setProperties, helper.getRelationshipProperties( relationshipId ) );
}
@Test
public void shouldRespondWith400WhenSettingRelationshipPropertiesWithBadJson()
{
long relationshipId = helper.createRelationship( "KNOWS" );
String json = "{\"name: \"Mattias\", \"age\": 30}";
Response response = service.setAllRelationshipProperties( FORCE, relationshipId, json );
assertEquals( 400, response.getStatus() );
}
@Test
public void shouldRespondWith404WhenSettingRelationshipPropertiesOnNonExistingRelationship()
{
long relationshipId = 99999999;
String json = "{\"name\": \"Mattias\", \"age\": 30}";
Response response = service.setAllRelationshipProperties( FORCE, relationshipId, json );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith204AndSetCorrectDataWhenSettingRelationshipProperty()
{
long relationshipId = helper.createRelationship( "KNOWS" );
String key = "name";
Object value = "Mattias";
String json = "\"" + value + "\"";
Response response = service.setRelationshipProperty( FORCE, relationshipId, key, json );
assertEquals( 204, response.getStatus() );
assertEquals( value, helper.getRelationshipProperties( relationshipId )
.get( "name" ) );
}
@Test
public void shouldRespondWith400WhenSettingRelationshipPropertyWithBadJson()
{
long relationshipId = helper.createRelationship( "KNOWS" );
String json = "}Mattias";
Response response = service.setRelationshipProperty( FORCE, relationshipId, "name", json );
assertEquals( 400, response.getStatus() );
}
@Test
public void shouldRespondWith404WhenSettingRelationshipPropertyOnNonExistingRelationship()
{
long relationshipId = 99999999;
String json = "\"Mattias\"";
Response response = service.setRelationshipProperty( FORCE, relationshipId, "name", json );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith204WhenSuccessfullyRemovedRelationshipProperties()
{
long relationshipId = helper.createRelationship( "KNOWS" );
helper.setRelationshipProperties( relationshipId, Collections.singletonMap( "foo", (Object) "bar" ) );
Response response = service.deleteAllRelationshipProperties( FORCE, relationshipId );
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldRespondWith204WhenSuccessfullyRemovedRelationshipPropertiesWhichAreEmpty()
{
long relationshipId = helper.createRelationship( "KNOWS" );
Response response = service.deleteAllRelationshipProperties( FORCE, relationshipId );
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldRespondWith404WhenNoRelationshipFromWhichToRemoveProperties()
{
long relationshipId = helper.createRelationship( "KNOWS" );
Response response = service.deleteAllRelationshipProperties( FORCE, relationshipId + 1000 );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith204WhenRemovingRelationshipProperty()
{
long relationshipId = helper.createRelationship( "KNOWS" );
helper.setRelationshipProperties( relationshipId, Collections.singletonMap( "foo", (Object) "bar" ) );
Response response = service.deleteRelationshipProperty( FORCE, relationshipId, "foo" );
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldRespondWith404WhenRemovingRelationshipPropertyWhichDoesNotExist()
{
long relationshipId = helper.createRelationship( "KNOWS" );
Response response = service.deleteRelationshipProperty( FORCE, relationshipId, "foo" );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWith404WhenNoRelationshipFromWhichToRemoveProperty()
{
long relationshipId = helper.createRelationship( "KNOWS" );
Response response = service.deleteRelationshipProperty( FORCE, relationshipId * 1000, "some-key" );
assertEquals( 404, response.getStatus() );
}
@Test
public void shouldRespondWithNoIndexOrOnlyNodeAutoIndex()
throws JsonParseException
{
Response isEnabled = service.isAutoIndexerEnabled( "node" );
assertEquals( "false", entityAsString( isEnabled ) );
Response response = service.getNodeIndexRoot();
if ( response.getStatus() == 200 )
{
Set<String> indexes = output.getResultAsMap()
.keySet();
assertEquals( 1, indexes.size() );
assertTrue( indexes.iterator()
.next()
.equals( NODE_AUTO_INDEX ) );
}
else
{
assertEquals( 204, response.getStatus() );
}
}
@Test
public void shouldRespondWithAvailableIndexNodeRoots() throws BadInputException
{
int numberOfAutoIndexesWhichCouldNotBeDeletedAtTestSetup = helper.getNodeIndexes().length;
String indexName = "someNodes";
helper.createNodeIndex( indexName );
Response response = service.getNodeIndexRoot();
assertEquals( 200, response.getStatus() );
Transaction transaction = graph.beginTx();
try
{
Map<String, Object> resultAsMap = output.getResultAsMap();
assertThat( resultAsMap.size(), is( numberOfAutoIndexesWhichCouldNotBeDeletedAtTestSetup + 1 ) );
assertThat( resultAsMap, hasKey( indexName ) );
}
finally
{
transaction.finish();
}
}
@Test
public void shouldRespondWithNoContentWhenNoRelationshipIndexesExist()
{
Response response = service.getRelationshipIndexRoot();
assertEquals( 204, response.getStatus() );
}
@Test
public void shouldRespondWithAvailableIndexRelationshipRoots() throws BadInputException
{
String indexName = "someRelationships";
helper.createRelationshipIndex( indexName );
Response response = service.getRelationshipIndexRoot();
assertEquals( 200, response.getStatus() );
Transaction transaction = graph.beginTx();
try
{
Map<String, Object> resultAsMap = output.getResultAsMap();
assertThat( resultAsMap.size(), is( 1 ) );
assertThat( resultAsMap, hasKey( indexName ) );
}
finally
{
transaction.finish();
}
}
@Test
public void shouldBeAbleToGetRoot() throws JsonParseException
{
Response response = service.getRoot();
assertEquals( 200, response.getStatus() );
String entity = entityAsString( response );
Map<String, Object> map = JsonHelper.jsonToMap( entity );
assertNotNull( map.get( "node" ) );
//this can be null
// assertNotNull( map.get( "reference_node" ) );
assertNotNull( map.get( "neo4j_version" ) );
assertNotNull( map.get( "node_index" ) );
assertNotNull( map.get( "extensions_info" ) );
assertNotNull( map.get( "relationship_index" ) );
assertNotNull( map.get( "batch" ) );
checkContentTypeCharsetUtf8(response);
}
@Test
public void shouldBeAbleToGetRootWhenNoReferenceNodePresent() throws Exception
{
helper.deleteNode( 0l );
Response response = service.getRoot();
assertEquals( 200, response.getStatus() );
String entity = entityAsString( response );
Map<String, Object> map = JsonHelper.jsonToMap( entity );
assertNotNull( map.get( "node" ) );
assertNotNull( map.get( "node_index" ) );
assertNotNull( map.get( "extensions_info" ) );
assertNotNull( map.get( "relationship_index" ) );
assertNull( map.get( "reference_node" ) );
checkContentTypeCharsetUtf8(response);
}
@Test
public void shouldBeAbleToIndexNode()
{
Response response = service.createNode( FORCE, null );
URI nodeUri = (URI) response.getMetadata()
.getFirst( "Location" );
Map<String, String> postBody = new HashMap<String, String>();
postBody.put( "key", "mykey" );
postBody.put( "value", "my/key" );
postBody.put( "uri", nodeUri.toString() );
response = service.addToNodeIndex( FORCE, "node", null, null, JsonHelper.createJsonFrom( postBody ) );
assertEquals( 201, response.getStatus() );
assertNotNull( response.getMetadata()
.getFirst( "Location" ) );
}
@Test
public void shouldBeAbleToIndexNodeUniquely()
{
Map<String, String> postBody = new HashMap<String, String>();
postBody.put( "key", "mykey" );
postBody.put( "value", "my/key" );
Response response = service.addToNodeIndex( FORCE, "unique-nodes", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( 201, response.getStatus() );
assertNotNull( response.getMetadata().getFirst( "Location" ) );
response = service.addToNodeIndex( FORCE, "unique-nodes", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( 200, response.getStatus() );
}
@Test
public void shouldNotBeAbleToIndexNodeUniquelyWithBothUriAndPropertiesInPayload() throws Exception
{
URI node = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
Map<String, Object> postBody = new HashMap<String, Object>();
postBody.put( "key", "mykey" );
postBody.put( "value", "my/key" );
postBody.put( "uri", node.toString() );
postBody.put( "properties", new HashMap<String, Object>() );
Response response = service.addToNodeIndex( FORCE, "unique-nodes", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( 400, response.getStatus() );
}
@Test
public void uniquelyIndexedNodeGetsTheSpecifiedKeyAndValueAsPropertiesIfNoPropertiesAreSpecified() throws Exception
{
final String key = "somekey", value = "somevalue";
Map<String, Object> postBody = new HashMap<String, Object>();
postBody.put( "key", key );
postBody.put( "value", value );
Response response = service.addToNodeIndex( FORCE, "unique-nodes", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( 201, response.getStatus() );
Object node = response.getMetadata().getFirst( "Location" );
assertNotNull( node );
String uri = node.toString();
Map<String, Object> properties = helper.getNodeProperties( parseLong( uri.substring( uri.lastIndexOf(
'/' ) + 1 ) ) );
assertEquals( 1, properties.size() );
assertEquals( value, properties.get( key ) );
}
@Test
public void specifiedPropertiesOverrideKeyAndValueForUniquelyIndexedNodes() throws Exception
{
final String key = "a_key", value = "a value";
Map<String, Object> postBody = new HashMap<String, Object>();
postBody.put( "key", key );
postBody.put( "value", value );
Map<String, Object> properties = new HashMap<String, Object>();
properties.put( "name", "Jürgen" );
properties.put( "age", "42" );
properties.put( "occupation", "crazy" );
postBody.put( "properties", properties );
Response response = service.addToNodeIndex( FORCE, "unique-nodes", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( 201, response.getStatus() );
Object node = response.getMetadata().getFirst( "Location" );
assertNotNull( node );
String uri = node.toString();
assertEquals( properties, helper.getNodeProperties( parseLong( uri.substring( uri.lastIndexOf( '/' ) + 1
) ) ) );
}
@Test
public void shouldNotBeAbleToCreateAnIndexWithEmptyName() throws Exception
{
URI node = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
Map<String, String> createRel = new HashMap<String, String>();
createRel.put( "to", node.toString() );
createRel.put( "type", "knows" );
URI rel = (URI) service.createRelationship( FORCE, helper.createNode(), JsonHelper.createJsonFrom( createRel
) ).getMetadata().getFirst( "Location" );
Map<String, String> indexPostBody = new HashMap<String, String>();
indexPostBody.put( "key", "mykey" );
indexPostBody.put( "value", "myvalue" );
indexPostBody.put( "uri", node.toString() );
Response response = service.addToNodeIndex( FORCE, "", "", "", JsonHelper.createJsonFrom( indexPostBody ) );
assertEquals( "http bad request when trying to create an index with empty name", 400, response.getStatus() );
indexPostBody.put( "uri", rel.toString() );
response = service.addToRelationshipIndex( FORCE, "", "", "", JsonHelper.createJsonFrom( indexPostBody ) );
assertEquals( "http bad request when trying to create an index with empty name", 400, response.getStatus() );
Map<String, String> basicIndexCreation = new HashMap<String, String>();
basicIndexCreation.put( "name", "" );
response = service.jsonCreateNodeIndex( FORCE, JsonHelper.createJsonFrom( basicIndexCreation ) );
assertEquals( "http bad request when trying to create an index with empty name", 400, response.getStatus() );
response = service.jsonCreateRelationshipIndex( FORCE, JsonHelper.createJsonFrom( basicIndexCreation ) );
assertEquals( "http bad request when trying to create an index with empty name", 400, response.getStatus() );
}
@Test
public void shouldNotBeAbleToIndexNodeUniquelyWithRequiredParameterMissing() throws Exception
{
service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
Map<String, Object> body = new HashMap<String, Object>();
body.put( "key", "mykey" );
body.put( "value", "my/key" );
for ( String key : body.keySet() )
{
Map<String, Object> postBody = new HashMap<String, Object>( body );
postBody.remove( key );
Response response = service.addToNodeIndex( FORCE, "unique-nodes", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( "unexpected response code with \"" + key + "\" missing.", 400, response.getStatus() );
}
}
@Test
public void shouldBeAbleToIndexRelationshipUniquely() throws Exception
{
URI start = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
URI end = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
Map<String, String> postBody = new HashMap<String, String>();
postBody.put( "key", "mykey" );
postBody.put( "value", "my/key" );
postBody.put( "start", start.toString() );
postBody.put( "end", end.toString() );
postBody.put( "type", "knows" );
for ( int i = 0; i < 2; i++ )
{
Response response = service.addToNodeIndex( FORCE, "unique-relationships", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( 201 - i, response.getStatus() );
if ( i == 0 )
{
assertNotNull( response.getMetadata().getFirst( "Location" ) );
}
}
}
@Test
public void uniquelyIndexedRelationshipGetsTheSpecifiedKeyAndValueAsPropertiesIfNoPropertiesAreSpecified() throws
Exception
{
final String key = "somekey", value = "somevalue";
URI start = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
URI end = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
Map<String, Object> postBody = new HashMap<String, Object>();
postBody.put( "key", key );
postBody.put( "value", value );
postBody.put( "start", start.toString() );
postBody.put( "end", end.toString() );
postBody.put( "type", "knows" );
Response response = service.addToRelationshipIndex( FORCE, "unique-relationships", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( 201, response.getStatus() );
Object rel = response.getMetadata().getFirst( "Location" );
assertNotNull( rel );
String uri = rel.toString();
Map<String, Object> properties = helper.getRelationshipProperties( parseLong( uri.substring( uri
.lastIndexOf( '/' ) + 1 ) ) );
assertEquals( 1, properties.size() );
assertEquals( value, properties.get( key ) );
}
@Test
public void specifiedPropertiesOverrideKeyAndValueForUniquelyIndexedRelationships() throws Exception
{
final String key = "a_key", value = "a value";
URI start = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
URI end = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
Map<String, Object> postBody = new HashMap<String, Object>();
postBody.put( "key", key );
postBody.put( "value", value );
postBody.put( "start", start.toString() );
postBody.put( "end", end.toString() );
postBody.put( "type", "knows" );
Map<String, Object> properties = new HashMap<String, Object>();
properties.put( "name", "Jürgen" );
properties.put( "age", "42" );
properties.put( "occupation", "crazy" );
postBody.put( "properties", properties );
Response response = service.addToRelationshipIndex( FORCE, "unique-relationships", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( 201, response.getStatus() );
Object rel = response.getMetadata().getFirst( "Location" );
assertNotNull( rel );
String uri = rel.toString();
assertEquals( properties, helper.getRelationshipProperties( parseLong( uri.substring( uri.lastIndexOf(
'/' ) + 1 ) ) ) );
}
@Test
public void shouldNotBeAbleToIndexRelationshipUniquelyWithBothUriAndCreationalDataInPayload() throws Exception
{
URI start = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
URI end = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
String path = start.getPath();
URI rel = (URI) service.createRelationship( FORCE,
parseLong( path.substring( path.lastIndexOf( '/' ) + 1 ) ),
"{\"to\":\"" + end + "\",\"type\":\"knows\"}" ).getMetadata()
.getFirst( "Location" );
Map<String, Object> unwanted = new HashMap<String, Object>();
unwanted.put( "properties", new HashMap() );
unwanted.put( "start", start.toString() );
unwanted.put( "end", end.toString() );
unwanted.put( "type", "friend" );
for ( Map.Entry<String, Object> bad : unwanted.entrySet() )
{
Map<String, Object> postBody = new HashMap<String, Object>();
postBody.put( "key", "mykey" );
postBody.put( "value", "my/key" );
postBody.put( "uri", rel.toString() );
postBody.put( bad.getKey(), bad.getValue() );
Response response = service.addToRelationshipIndex( FORCE, "unique-relationships", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( "unexpected response code with \"" + bad.getKey() + "\".", 400, response.getStatus() );
}
}
@Test
public void shouldNotBeAbleToIndexRelationshipUniquelyWithRequiredParameterMissing() throws Exception
{
URI start = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
URI end = (URI) service.createNode( FORCE, null ).getMetadata().getFirst( "Location" );
Map<String, Object> body = new HashMap<String, Object>();
body.put( "key", "mykey" );
body.put( "value", "my/key" );
body.put( "start", start.toString() );
body.put( "end", end.toString() );
body.put( "type", "knows" );
for ( String key : body.keySet() )
{
Map<String, Object> postBody = new HashMap<String, Object>( body );
postBody.remove( key );
Response response = service.addToRelationshipIndex( FORCE, "unique-relationships", "", "",
JsonHelper.createJsonFrom( postBody ) );
assertEquals( "unexpected response code with \"" + key + "\" missing.", 400, response.getStatus() );
}
}
@Test
public void shouldBeAbleToRemoveNodeIndex()
{
String indexName = "myFancyIndex";
int numberOfAutoIndexesWhichCouldNotBeDeletedAtTestSetup = helper.getNodeIndexes().length;
helper.createNodeIndex( indexName );
helper.createNodeIndex( "another one" );
assertEquals( numberOfAutoIndexesWhichCouldNotBeDeletedAtTestSetup + 2, helper.getNodeIndexes().length );
Response response = service.deleteNodeIndex( FORCE, indexName );
assertEquals( 204, response.getStatus() );
assertEquals( numberOfAutoIndexesWhichCouldNotBeDeletedAtTestSetup + 1, helper.getNodeIndexes().length );
}
@Test
public void shouldBeAbleToRemoveRelationshipIndex()
{
String indexName = "myFancyIndex";
assertEquals( 0, helper.getRelationshipIndexes().length );
helper.createRelationshipIndex( indexName );
assertEquals( 1, helper.getRelationshipIndexes().length );
Response response = service.deleteRelationshipIndex( FORCE, indexName );
assertEquals( 204, response.getStatus() );
assertEquals( 0, helper.getRelationshipIndexes().length );
}
@Test
public void shouldBeAbleToGetNodeRepresentationFromIndexUri() throws Exception
{
String key = "key_get_noderep";
String value = "value";
long nodeId = helper.createNode();
String indexName = "all-the-best-nodes";
helper.addNodeToIndex( indexName, key, value, nodeId );
Response response = service.getNodeFromIndexUri( indexName, key, value, nodeId );
assertEquals( 200, response.getStatus() );
checkContentTypeCharsetUtf8(response);
assertNull( response.getMetadata()
.get( "Location" ) );
Map<String, Object> map = JsonHelper.jsonToMap( entityAsString( response ) );
assertNotNull( map );
assertTrue( map.containsKey( "self" ) );
}
private void checkContentTypeCharsetUtf8(Response response)
{
assertTrue( response.getMetadata()
.getFirst( HttpHeaders.CONTENT_TYPE ).toString().contains( "UTF-8" ));
}
@Test
public void shouldBeAbleToGetRelationshipRepresentationFromIndexUri() throws Exception
{
String key = "key_get_noderep";
String value = "value";
long startNodeId = helper.createNode();
long endNodeId = helper.createNode();
String relationshipType = "knows";
long relationshipId = helper.createRelationship( relationshipType, startNodeId, endNodeId );
String indexName = "all-the-best-relationships";
helper.addRelationshipToIndex( indexName, key, value, relationshipId );
Response response = service.getRelationshipFromIndexUri( indexName, key, value, relationshipId );
assertEquals( 200, response.getStatus() );
checkContentTypeCharsetUtf8(response);
assertNull( response.getMetadata()
.get( "Location" ) );
Map<String, Object> map = JsonHelper.jsonToMap( entityAsString( response ) );
assertNotNull( map );
assertTrue( map.containsKey( "self" ) );
}
@Test
public void shouldBeAbleToGetListOfNodeRepresentationsFromIndexLookup() throws Exception
{
ModelBuilder.DomainModel matrixers = ModelBuilder.generateMatrix( service );
Map.Entry<String, String> indexedKeyValue = matrixers.indexedNodeKeyValues.entrySet()
.iterator()
.next();
Response response = service.getIndexedNodes( matrixers.nodeIndexName, indexedKeyValue.getKey(),
indexedKeyValue.getValue() );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
Collection<?> items = (Collection<?>) JsonHelper.jsonToSingleValue( entityAsString( response ) );
int counter = 0;
for ( Object item : items )
{
Map<?, ?> map = (Map<?, ?>) item;
Map<?, ?> properties = (Map<?, ?>) map.get( "data" );
assertNotNull( map.get( "self" ) );
String indexedUri = (String) map.get( "indexed" );
assertEquals( matrixers.indexedNodeUriToEntityMap.get( new URI( indexedUri ) ).properties.get( "name" ),
properties.get( "name" ) );
counter++;
}
assertEquals( 2, counter );
}
@Test
public void shouldBeAbleToGetListOfNodeRepresentationsFromIndexQuery() throws Exception
{
ModelBuilder.DomainModel matrixers = ModelBuilder.generateMatrix( service );
Map.Entry<String, String> indexedKeyValue = matrixers.indexedNodeKeyValues.entrySet()
.iterator()
.next();
// query for the first letter with which the nodes were indexed.
Response response = service.getIndexedNodesByQuery( matrixers.nodeIndexName, indexedKeyValue.getKey() + ":"
+ indexedKeyValue.getValue().substring( 0, 1 ) + "*",
"" /*default ordering*/ );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
Collection<?> items = (Collection<?>) JsonHelper.jsonToSingleValue( entityAsString( response ) );
int counter = 0;
for ( Object item : items )
{
Map<?, ?> map = (Map<?, ?>) item;
Map<?, ?> properties = (Map<?, ?>) map.get( "data" );
String indexedUri = (String) map.get( "indexed" ); // unlike exact
// match, a query
// can not return
// a sensible
// index uri for
// the result
assertNull( indexedUri );
String selfUri = (String) map.get( "self" );
assertNotNull( selfUri );
assertEquals( matrixers.nodeUriToEntityMap.get( new URI( selfUri ) ).properties.get( "name" ),
properties.get( "name" ) );
counter++;
}
assertThat( counter, is( greaterThanOrEqualTo( 2 ) ) );
}
@Test
public void shouldBeAbleToGetListOfNodeRepresentationsFromIndexQueryWithDefaultKey() throws Exception
{
ModelBuilder.DomainModel matrixers = ModelBuilder.generateMatrix( service );
Map.Entry<String, String> indexedKeyValue = matrixers.indexedNodeKeyValues.entrySet()
.iterator()
.next();
// query for the first letter with which the nodes were indexed.
Response response = service.getIndexedNodesByQuery( matrixers.nodeIndexName, indexedKeyValue.getKey(),
indexedKeyValue.getValue().substring( 0, 1 ) + "*", "" /*default ordering*/ );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
Collection<?> items = (Collection<?>) JsonHelper.jsonToSingleValue( entityAsString( response ) );
int counter = 0;
for ( Object item : items )
{
Map<?, ?> map = (Map<?, ?>) item;
Map<?, ?> properties = (Map<?, ?>) map.get( "data" );
String indexedUri = (String) map.get( "indexed" ); // unlike exact
// match, a query
// can not return
// a sensible
// index uri for
// the result
assertNull( indexedUri );
String selfUri = (String) map.get( "self" );
assertNotNull( selfUri );
assertEquals( matrixers.nodeUriToEntityMap.get( new URI( selfUri ) ).properties.get( "name" ),
properties.get( "name" ) );
counter++;
}
assertThat( counter, is( greaterThanOrEqualTo( 2 ) ) );
}
@Test
public void shouldBeAbleToGetListOfRelationshipRepresentationsFromIndexLookup() throws Exception
{
String key = "key_get";
String value = "value";
long startNodeId = helper.createNode();
long endNodeId = helper.createNode();
String relationshipType1 = "KNOWS";
long relationshipId1 = helper.createRelationship( relationshipType1, startNodeId, endNodeId );
String relationshipType2 = "PLAYS-NICE-WITH";
long relationshipId2 = helper.createRelationship( relationshipType2, startNodeId, endNodeId );
String indexName = "matrixal-relationships";
helper.createRelationshipIndex( indexName );
helper.addRelationshipToIndex( indexName, key, value, relationshipId1 );
helper.addRelationshipToIndex( indexName, key, value, relationshipId2 );
Response response = service.getIndexedRelationships( indexName, key, value );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
Collection<?> items = (Collection<?>) JsonHelper.jsonToSingleValue( entityAsString( response ) );
int counter = 0;
for ( Object item : items )
{
Map<?, ?> map = (Map<?, ?>) item;
assertNotNull( map.get( "self" ) );
String indexedUri = (String) map.get( "indexed" );
assertThat( indexedUri, containsString( key ) );
assertThat( indexedUri, containsString( value ) );
assertTrue( indexedUri.endsWith( Long.toString( relationshipId1 ) )
|| indexedUri.endsWith( Long.toString( relationshipId2 ) ) );
counter++;
}
assertEquals( 2, counter );
}
@Test
public void shouldBeAbleToGetListOfRelationshipRepresentationsFromIndexQuery() throws Exception
{
String key = "key_get";
String value = "value";
long startNodeId = helper.createNode();
long endNodeId = helper.createNode();
String relationshipType1 = "KNOWS";
long relationshipId1 = helper.createRelationship( relationshipType1, startNodeId, endNodeId );
String relationshipType2 = "PLAYS-NICE-WITH";
long relationshipId2 = helper.createRelationship( relationshipType2, startNodeId, endNodeId );
String indexName = "matrixal-relationships";
helper.createRelationshipIndex( indexName );
helper.addRelationshipToIndex( indexName, key, value, relationshipId1 );
helper.addRelationshipToIndex( indexName, key, value, relationshipId2 );
Response response = service.getIndexedRelationshipsByQuery( indexName,
key + ":" + value.substring( 0, 1 ) + "*", "" /*default ordering*/ );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
Collection<?> items = (Collection<?>) JsonHelper.jsonToSingleValue( entityAsString( response ) );
int counter = 0;
for ( Object item : items )
{
Map<?, ?> map = (Map<?, ?>) item;
String indexedUri = (String) map.get( "indexed" );
assertNull( indexedUri ); // queries can not return a sensible index
// uri
String selfUri = (String) map.get( "self" );
assertNotNull( selfUri );
assertTrue( selfUri.endsWith( Long.toString( relationshipId1 ) )
|| selfUri.endsWith( Long.toString( relationshipId2 ) ) );
counter++;
}
assertThat( counter, is( greaterThanOrEqualTo( 2 ) ) );
}
@Test
public void shouldBeAbleToGetListOfRelationshipRepresentationsFromIndexQueryWithDefaultKey() throws Exception
{
String key = "key_get";
String value = "value";
long startNodeId = helper.createNode();
long endNodeId = helper.createNode();
String relationshipType1 = "KNOWS";
long relationshipId1 = helper.createRelationship( relationshipType1, startNodeId, endNodeId );
String relationshipType2 = "PLAYS-NICE-WITH";
long relationshipId2 = helper.createRelationship( relationshipType2, startNodeId, endNodeId );
String indexName = "matrixal-relationships";
helper.createRelationshipIndex( indexName );
helper.addRelationshipToIndex( indexName, key, value, relationshipId1 );
helper.addRelationshipToIndex( indexName, key, value, relationshipId2 );
Response response = service.getIndexedRelationshipsByQuery( indexName,
key, value.substring( 0, 1 ) + "*", "" /*default ordering*/ );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
Collection<?> items = (Collection<?>) JsonHelper.jsonToSingleValue( entityAsString( response ) );
int counter = 0;
for ( Object item : items )
{
Map<?, ?> map = (Map<?, ?>) item;
String indexedUri = (String) map.get( "indexed" );
assertNull( indexedUri ); // queries can not return a sensible index
// uri
String selfUri = (String) map.get( "self" );
assertNotNull( selfUri );
assertTrue( selfUri.endsWith( Long.toString( relationshipId1 ) )
|| selfUri.endsWith( Long.toString( relationshipId2 ) ) );
counter++;
}
assertThat( counter, is( greaterThanOrEqualTo( 2 ) ) );
}
@Test
public void shouldGet200AndEmptyListWhenNothingFoundInIndexLookup() throws Exception
{
String indexName = "nothing-in-this-index";
helper.createNodeIndex( indexName );
Response response = service.getIndexedNodes( indexName, "fooo", "baaar" );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
checkContentTypeCharsetUtf8(response);
String entity = entityAsString( response );
Object parsedJson = JsonHelper.jsonToSingleValue( entity );
assertTrue( parsedJson instanceof Collection<?> );
assertTrue( ((Collection<?>) parsedJson).isEmpty() );
}
@Test
public void shouldBeAbleToRemoveNodeFromIndex()
{
long nodeId = helper.createNode();
String key = "key_remove";
String value = "value";
helper.addNodeToIndex( "node", key, value, nodeId );
assertEquals( 1, helper.getIndexedNodes( "node", key, value )
.size() );
Response response = service.deleteFromNodeIndex( FORCE, "node", key, value, nodeId );
assertEquals( Status.NO_CONTENT.getStatusCode(), response.getStatus() );
assertEquals( 0, helper.getIndexedNodes( "node", key, value )
.size() );
}
@Test
public void shouldBeAbleToRemoveRelationshipFromIndex()
{
long startNodeId = helper.createNode();
long endNodeId = helper.createNode();
String relationshipType = "related-to";
long relationshipId = helper.createRelationship( relationshipType, startNodeId, endNodeId );
String key = "key_remove";
String value = "value";
String indexName = "relationships";
helper.addRelationshipToIndex( indexName, key, value, relationshipId );
assertEquals( 1, helper.getIndexedRelationships( indexName, key, value )
.size() );
Response response = service.deleteFromRelationshipIndex( FORCE, indexName, key, value, relationshipId );
assertEquals( Status.NO_CONTENT.getStatusCode(), response.getStatus() );
assertEquals( 0, helper.getIndexedRelationships( indexName, key, value )
.size() );
}
@Test
public void shouldGet404IfRemovingNonExistentNodeIndexing()
{
Response response = service.deleteFromNodeIndex( FORCE, "nodes", "bogus", "bogus", 999999 );
assertEquals( Status.NOT_FOUND.getStatusCode(), response.getStatus() );
}
@Test
public void shouldGet404IfRemovingNonExistentRelationshipIndexing()
{
Response response = service.deleteFromRelationshipIndex( FORCE, "relationships", "bogus", "bogus", 999999 );
assertEquals( Status.NOT_FOUND.getStatusCode(), response.getStatus() );
}
@Test
public void shouldGet404WhenTraversingFromNonExistentNode()
{
Response response = service.traverse( 9999999, TraverserReturnType.node, "{}" );
assertEquals( Status.NOT_FOUND.getStatusCode(), response.getStatus() );
}
@Test
public void shouldGet200WhenNoHitsReturnedFromTraverse()
{
long startNode = helper.createNode();
Transaction transaction = graph.beginTx();
try
{
Response response = service.traverse( startNode, TraverserReturnType.node, "" );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
assertThat( output.getResultAsList().size(), is( 0 ) );
}
finally
{
transaction.finish();
}
}
@Test
public void shouldGetSomeHitsWhenTraversingWithDefaultDescription()
{
long startNode = helper.createNode();
long child1_l1 = helper.createNode();
helper.createRelationship( "knows", startNode, child1_l1 );
long child2_l1 = helper.createNode();
helper.createRelationship( "knows", startNode, child2_l1 );
long child1_l2 = helper.createNode();
helper.createRelationship( "knows", child2_l1, child1_l2 );
Response response = service.traverse( startNode, TraverserReturnType.node, "" );
String entity = entityAsString( response );
assertTrue( entity.contains( "/node/" + child1_l1 ) );
assertTrue( entity.contains( "/node/" + child2_l1 ) );
assertFalse( entity.contains( "/node/" + child1_l2 ) );
checkContentTypeCharsetUtf8(response);
}
@Test
public void shouldBeAbleToDescribeTraverser()
{
long startNode = helper.createNode( MapUtil.map( "name", "Mattias" ) );
long node1 = helper.createNode( MapUtil.map( "name", "Emil" ) );
long node2 = helper.createNode( MapUtil.map( "name", "Johan" ) );
long node3 = helper.createNode( MapUtil.map( "name", "Tobias" ) );
helper.createRelationship( "knows", startNode, node1 );
helper.createRelationship( "knows", startNode, node2 );
helper.createRelationship( "knows", node1, node3 );
String description = "{"
+ "\"prune_evaluator\":{\"language\":\"builtin\",\"name\":\"none\"},"
+ "\"return_filter\":{\"language\":\"javascript\",\"body\":\"position.endNode().getProperty('name')" +
".toLowerCase().contains('t');\"},"
+ "\"order\":\"depth_first\","
+ "\"relationships\":{\"type\":\"knows\",\"direction\":\"all\"}" + "}";
Response response = service.traverse( startNode, TraverserReturnType.node, description );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
String entity = entityAsString( response );
assertTrue( entity.contains( NODE_SUBPATH + startNode ) );
assertFalse( entity.contains( NODE_SUBPATH + node1 ) );
assertFalse( entity.contains( NODE_SUBPATH + node2 ) );
assertTrue( entity.contains( NODE_SUBPATH + node3 ) );
}
@Test
public void shouldBeAbleToGetOtherResultTypesWhenTraversing()
{
long startNode = helper.createNode( MapUtil.map( "name", "Mattias" ) );
long node1 = helper.createNode( MapUtil.map( "name", "Emil" ) );
long node2 = helper.createNode( MapUtil.map( "name", "Johan" ) );
long node3 = helper.createNode( MapUtil.map( "name", "Tobias" ) );
long rel1 = helper.createRelationship( "knows", startNode, node1 );
long rel2 = helper.createRelationship( "knows", startNode, node2 );
long rel3 = helper.createRelationship( "knows", node1, node3 );
Response response = service.traverse( startNode, TraverserReturnType.relationship, "" );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
String entity = entityAsString( response );
assertTrue( entity.contains( "/relationship/" + rel1 ) );
assertTrue( entity.contains( "/relationship/" + rel2 ) );
assertFalse( entity.contains( "/relationship/" + rel3 ) );
response = service.traverse( startNode, TraverserReturnType.path, "" );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
entity = entityAsString( response );
assertTrue( entity.contains( "nodes" ) );
assertTrue( entity.contains( "relationships" ) );
assertTrue( entity.contains( "length" ) );
response = service.traverse( startNode, TraverserReturnType.fullpath, "" );
assertEquals( Status.OK.getStatusCode(), response.getStatus() );
entity = entityAsString( response );
assertTrue( entity.contains( "nodes" ) );
assertTrue( entity.contains( "data" ) );
assertTrue( entity.contains( "type" ) );
assertTrue( entity.contains( "self" ) );
assertTrue( entity.contains( "outgoing_relationships" ) );
assertTrue( entity.contains( "incoming_relationships" ) );
assertTrue( entity.contains( "relationships" ) );
assertTrue( entity.contains( "length" ) );
}
private static String markWithUnicodeMarker( String string )
{
return String.valueOf( (char) 0xfeff ) + string;
}
@Test
public void shouldBeAbleToFindSinglePathBetweenTwoNodes() throws Exception
{
long n1 = helper.createNode();
long n2 = helper.createNode();
helper.createRelationship( "knows", n1, n2 );
Map<String, Object> config = MapUtil.map( "max depth", 3, "algorithm", "shortestPath", "to",
Long.toString( n2 ), "relationships", MapUtil.map( "type", "knows", "direction", "out" ) );
String payload = JsonHelper.createJsonFrom( config );
Response response = service.singlePath( n1, payload );
assertThat( response.getStatus(), is( 200 ) );
Transaction transaction = graph.beginTx();
try
{
Map<String, Object> resultAsMap = output.getResultAsMap();
assertThat( (Integer) resultAsMap.get( "length" ), is( 1 ) );
}
finally
{
transaction.finish();
}
}
@Test
public void shouldBeAbleToFindSinglePathBetweenTwoNodesEvenWhenAskingForAllPaths() throws Exception
{
long n1 = helper.createNode();
long n2 = helper.createNode();
helper.createRelationship( "knows", n1, n2 );
Map<String, Object> config = MapUtil.map( "max depth", 3, "algorithm", "shortestPath", "to",
Long.toString( n2 ), "relationships", MapUtil.map( "type", "knows", "direction", "out" ) );
String payload = JsonHelper.createJsonFrom( config );
Response response = service.allPaths( n1, payload );
assertThat( response.getStatus(), is( 200 ) );
Transaction transaction = graph.beginTx();
try
{
List<Object> resultAsList = output.getResultAsList();
assertThat( resultAsList.size(), is( 1 ) );
}
finally
{
transaction.finish();
}
}
@Test
public void shouldBeAbleToParseJsonEvenWithUnicodeMarkerAtTheStart() throws Exception
{
Response response = service.createNode( FORCE, markWithUnicodeMarker( "{\"name\":\"Mattias\"}" ) );
assertEquals( Status.CREATED.getStatusCode(), response.getStatus() );
String nodeLocation = response.getMetadata()
.getFirst( HttpHeaders.LOCATION )
.toString();
long node = helper.createNode();
assertEquals( Status.NO_CONTENT.getStatusCode(),
service.setNodeProperty( FORCE, node, "foo", markWithUnicodeMarker( "\"bar\"" ) )
.getStatus() );
assertEquals( Status.NO_CONTENT.getStatusCode(),
service.setNodeProperty( FORCE, node, "foo", markWithUnicodeMarker( "" + 10 ) )
.getStatus() );
assertEquals( Status.NO_CONTENT.getStatusCode(),
service.setAllNodeProperties( FORCE, node, markWithUnicodeMarker( "{\"name\":\"Something\"," +
"\"number\":10}" ) )
.getStatus() );
assertEquals(
Status.CREATED.getStatusCode(),
service.createRelationship( FORCE, node,
markWithUnicodeMarker( "{\"to\":\"" + nodeLocation + "\",\"type\":\"knows\"}" ) )
.getStatus() );
long relationship = helper.createRelationship( "knows" );
assertEquals( Status.NO_CONTENT.getStatusCode(),
service.setRelationshipProperty( FORCE, relationship, "foo", markWithUnicodeMarker( "\"bar\"" ) )
.getStatus() );
assertEquals( Status.NO_CONTENT.getStatusCode(),
service.setRelationshipProperty( FORCE, relationship, "foo", markWithUnicodeMarker( "" + 10 ) )
.getStatus() );
assertEquals(
Status.NO_CONTENT.getStatusCode(),
service.setAllRelationshipProperties( FORCE, relationship,
markWithUnicodeMarker( "{\"name\":\"Something\",\"number\":10}" ) )
.getStatus() );
assertEquals(
Status.CREATED.getStatusCode(),
service.addToNodeIndex( FORCE,
"node", null, null,
markWithUnicodeMarker( "{\"key\":\"foo\", \"value\":\"bar\", \"uri\": \"" + nodeLocation
+ "\"}" ) )
.getStatus() );
assertEquals( Status.OK.getStatusCode(),
service.traverse( node, TraverserReturnType.node, markWithUnicodeMarker( "{\"max depth\":2}" ) )
.getStatus() );
}
@Test
public void shouldAdvertiseUriForQueringAllRelationsInTheDatabase()
{
Response response = service.getRoot();
assertThat( new String( (byte[]) response.getEntity() ),
containsString( "\"relationship_types\" : \"http://neo4j.org/relationship/types\"" ) );
}
@Test
public void nodeAutoIndexerEnabling()
{
testAutoIndexEnableForType( "node" );
}
@Test
public void relationshipAutoIndexerEnabling()
{
testAutoIndexEnableForType( "relationship" );
}
@Test
public void addRemoveAutoindexPropertiesOnNodes() throws JsonParseException
{
addRemoveAutoindexProperties( "node" );
}
@Test
public void addRemoveAutoindexPropertiesOnRelationships() throws JsonParseException
{
addRemoveAutoindexProperties( "relationship" );
}
@Test
public void nodeAutoindexingSupposedToWork() throws JsonParseException
{
String type = "node";
// Response response = service.getAutoIndexedProperties(type);
// assertEquals(200, response.getStatus());
// List<String> properties = (List<String>) JsonHelper.readJson(entityAsString(response));
// assertEquals(0, properties.size());
Response response = service.startAutoIndexingProperty( type, "myAutoIndexedProperty" );
assertEquals( 204, response.getStatus() );
response = service.setAutoIndexerEnabled( type, "true" );
assertEquals( 204, response.getStatus() );
service.createNode( FORCE, "{\"myAutoIndexedProperty\" : \"value\"}" );
Transaction transaction = graph.beginTx();
try
{
IndexHits<Node> indexResult = database.getIndexManager().getNodeAutoIndexer().getAutoIndex().get(
"myAutoIndexedProperty", "value" );
assertEquals( 1, indexResult.size() );
}
finally
{
transaction.finish();
}
}
@SuppressWarnings("unchecked")
private void addRemoveAutoindexProperties( String type ) throws JsonParseException
{
Response response = service.getAutoIndexedProperties( type );
assertEquals( 200, response.getStatus() );
String entity = entityAsString( response );
List<String> properties = (List<String>) JsonHelper.readJson( entity );
assertEquals( 0, properties.size() );
response = service.startAutoIndexingProperty( type, "myAutoIndexedProperty1" );
assertEquals( 204, response.getStatus() );
response = service.startAutoIndexingProperty( type, "myAutoIndexedProperty2" );
assertEquals( 204, response.getStatus() );
response = service.getAutoIndexedProperties( type );
assertEquals( 200, response.getStatus() );
entity = entityAsString( response );
properties = (List<String>) JsonHelper.readJson( entity );
assertEquals( 2, properties.size() );
assertTrue( properties.contains( "myAutoIndexedProperty1" ) );
assertTrue( properties.contains( "myAutoIndexedProperty2" ) );
response = service.stopAutoIndexingProperty( type, "myAutoIndexedProperty2" );
assertEquals( 204, response.getStatus() );
response = service.getAutoIndexedProperties( type );
assertEquals( 200, response.getStatus() );
entity = entityAsString( response );
properties = (List<String>) JsonHelper.readJson( entity );
assertEquals( 1, properties.size() );
assertTrue( properties.contains( "myAutoIndexedProperty1" ) );
}
private void testAutoIndexEnableForType( String type )
{
Response response = service.isAutoIndexerEnabled( type );
assertEquals( 200, response.getStatus() );
assertFalse( Boolean.parseBoolean( entityAsString( response ) ) );
response = service.setAutoIndexerEnabled( type, "true" );
assertEquals( 204, response.getStatus() );
response = service.isAutoIndexerEnabled( type );
assertEquals( 200, response.getStatus() );
assertTrue( Boolean.parseBoolean( entityAsString( response ) ) );
response = service.setAutoIndexerEnabled( type, "false" );
assertEquals( 204, response.getStatus() );
response = service.isAutoIndexerEnabled( type );
assertEquals( 200, response.getStatus() );
assertFalse( Boolean.parseBoolean( entityAsString( response ) ) );
}
}
| false
|
community_server_src_test_java_org_neo4j_server_rest_web_RestfulGraphDatabaseTest.java
|
2,238
|
public class SecurityRulesModuleTest
{
@Test
public void shouldStopCleanlyEvenWhenItHasntBeenStarted()
{
new SecurityRulesModule( null, null, DevNullLoggingService.DEV_NULL ).stop();
}
}
| false
|
community_server_src_test_java_org_neo4j_server_modules_SecurityRulesModuleTest.java
|
2,239
|
public class RESTApiModuleTest
{
@Test
public void shouldRegisterASingleUri() throws Exception
{
WebServer webServer = mock( WebServer.class );
Configuration config = new PropertiesConfiguration();
String path = "/db/data";
config.addProperty( Configurator.REST_API_PATH_PROPERTY_KEY, path );
Database db = mock(Database.class);
RESTApiModule module = new RESTApiModule(webServer, db, config, DEV_NULL);
module.start();
verify( webServer ).addJAXRSClasses( any( List.class ), anyString(), anyCollection() );
}
}
| false
|
community_server_src_test_java_org_neo4j_server_modules_RESTApiModuleTest.java
|
2,240
|
public class RESTApiModule implements ServerModule
{
private PluginManager plugins;
private final Configuration config;
private final WebServer webServer;
private final Database database;
private GuardingRequestFilter requestTimeLimitFilter;
private final ConsoleLogger log;
private final Logging logging;
public RESTApiModule( WebServer webServer, Database database, Configuration config, Logging logging )
{
this.webServer = webServer;
this.config = config;
this.database = database;
this.logging = logging;
this.log = logging.getConsoleLog( getClass() );
}
@Override
public void start()
{
try
{
URI restApiUri = restApiUri( );
webServer.addJAXRSClasses( getClassNames(), restApiUri.toString(), null );
loadPlugins();
setupRequestTimeLimit();
log.log( "Mounted REST API at [%s]", restApiUri.toString() );
}
catch ( URISyntaxException e )
{
log.warn( "Unable to mount REST API", e );
}
}
private List<String> getClassNames()
{
return listFrom(
RestfulGraphDatabase.class.getName(),
TransactionalService.class.getName(),
CypherService.class.getName(),
DatabaseMetadataService.class.getName(),
ExtensionService.class.getName(),
ResourcesService.class.getName(),
BatchOperationService.class.getName() );
}
@Override
public void stop()
{
try
{
webServer.removeJAXRSClasses( getClassNames(), restApiUri().toString() );
tearDownRequestTimeLimit();
unloadPlugins();
}
catch ( URISyntaxException e )
{
log.warn( "Unable to unmount REST API", e );
}
}
private void tearDownRequestTimeLimit() {
if(requestTimeLimitFilter != null)
{
webServer.removeFilter(requestTimeLimitFilter, "/*");
}
}
private void setupRequestTimeLimit() {
Integer limit = config.getInteger( WEBSERVER_LIMIT_EXECUTION_TIME_PROPERTY_KEY, null );
if ( limit != null )
{
try
{
Guard guard = database.getGraph().getDependencyResolver().resolveDependency( Guard.class );
this.requestTimeLimitFilter = new GuardingRequestFilter( guard, limit );
webServer.addFilter(requestTimeLimitFilter , "/*" );
}
catch ( IllegalArgumentException e )
{
//TODO enable guard and restart EmbeddedGraphdb
throw new RuntimeException( "Unable to use guard, you have to enable guard in neo4j.properties", e );
}
}
}
private URI restApiUri() throws URISyntaxException
{
return new URI( config.getString( Configurator.REST_API_PATH_PROPERTY_KEY, Configurator.DEFAULT_DATA_API_PATH ) );
}
private void loadPlugins()
{
plugins = new PluginManager( config, logging );
}
private void unloadPlugins() {
// TODO
}
public PluginManager getPlugins()
{
return plugins;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_modules_RESTApiModule.java
|
2,241
|
public class Neo4jBrowserModule implements ServerModule
{
private static final String DEFAULT_NEO4J_BROWSER_PATH = "/browser";
private static final String DEFAULT_NEO4J_BROWSER_STATIC_WEB_CONTENT_LOCATION = "browser";
private final Configuration config;
private final WebServer webServer;
private final Database database;
private final ConsoleLogger log;
public Neo4jBrowserModule(WebServer webServer, Configuration config, Logging logging, Database database)
{
this.webServer = webServer;
this.config = config;
this.database = database;
this.log = logging.getConsoleLog( getClass() );
}
@Override
public void start()
{
webServer.addStaticContent( DEFAULT_NEO4J_BROWSER_STATIC_WEB_CONTENT_LOCATION, DEFAULT_NEO4J_BROWSER_PATH );
log.log( "Mounted Neo4j Browser at [%s]", DEFAULT_NEO4J_BROWSER_PATH );
}
@Override
public void stop()
{
webServer.removeStaticContent( DEFAULT_NEO4J_BROWSER_STATIC_WEB_CONTENT_LOCATION, DEFAULT_NEO4J_BROWSER_PATH );
}
}
| false
|
community_server_src_main_java_org_neo4j_server_modules_Neo4jBrowserModule.java
|
2,242
|
public class ManagementApiModuleTest
{
@Test
public void shouldRegisterASingleUri() throws Exception
{
WebServer webServer = mock( WebServer.class );
CommunityNeoServer neoServer = mock( CommunityNeoServer.class );
when( neoServer.baseUri() ).thenReturn( new URI( "http://localhost:7575" ) );
when( neoServer.getWebServer() ).thenReturn( webServer );
Configuration config = new PropertiesConfiguration();
String managementPath = "/db/manage";
config.addProperty( Configurator.MANAGEMENT_PATH_PROPERTY_KEY, managementPath );
when( neoServer.getConfiguration() ).thenReturn( config );
ManagementApiModule module = new ManagementApiModule(webServer, config, DevNullLoggingService.DEV_NULL);
module.start();
verify( webServer ).addJAXRSClasses( any( List.class ), anyString(), anyCollection() );
}
}
| false
|
community_server_src_test_java_org_neo4j_server_modules_ManagementApiModuleTest.java
|
2,243
|
public class ManagementApiModule implements ServerModule
{
private final Configuration config;
private final WebServer webServer;
private final ConsoleLogger log;
public ManagementApiModule(WebServer webServer, Configuration config, Logging logging)
{
this.webServer = webServer;
this.config = config;
this.log = logging.getConsoleLog( getClass() );
}
@Override
public void start()
{
String serverMountPoint = managementApiUri().toString();
webServer.addJAXRSClasses( getClassNames(), serverMountPoint, null);
log.log( "Mounted management API at [%s]", serverMountPoint );
}
private List<String> getClassNames()
{
return listFrom(
JmxService.class.getName(),
MonitorService.class.getName(),
RootService.class.getName(),
ConsoleService.class.getName(),
VersionAndEditionService.class.getName() );
}
@Override
public void stop()
{
webServer.removeJAXRSClasses( getClassNames(),
managementApiUri( ).toString() );
}
private URI managementApiUri( )
{
return URI.create( config.getString( Configurator.MANAGEMENT_PATH_PROPERTY_KEY,
Configurator.DEFAULT_MANAGEMENT_API_PATH ) );
}
}
| false
|
community_server_src_main_java_org_neo4j_server_modules_ManagementApiModule.java
|
2,244
|
public class ExtensionInitializer
{
private final Iterable<PluginLifecycle> lifecycles;
private final NeoServer neoServer;
public ExtensionInitializer( NeoServer neoServer )
{
this.neoServer = neoServer;
lifecycles = Service.load( PluginLifecycle.class );
}
public Collection<Injectable<?>> initializePackages( Iterable<String> packageNames )
{
GraphDatabaseAPI graphDatabaseService = neoServer.getDatabase().getGraph();
Configuration configuration = neoServer.getConfiguration();
Collection<Injectable<?>> injectables = new HashSet<Injectable<?>>();
for ( PluginLifecycle lifecycle : lifecycles )
{
if ( hasPackage( lifecycle, packageNames ) )
{
if ( lifecycle instanceof SPIPluginLifecycle )
{
SPIPluginLifecycle lifeCycleSpi = (SPIPluginLifecycle) lifecycle;
injectables.addAll( lifeCycleSpi.start( neoServer ) );
}
else
{
injectables.addAll( lifecycle.start( graphDatabaseService, configuration ) );
}
}
}
return injectables;
}
private boolean hasPackage( PluginLifecycle pluginLifecycle, Iterable<String> packageNames )
{
String lifecyclePackageName = pluginLifecycle.getClass().getPackage().getName();
for ( String packageName : packageNames )
{
if ( lifecyclePackageName.startsWith( packageName ) )
{
return true;
}
}
return false;
}
public void stop()
{
for ( PluginLifecycle pluginLifecycle : lifecycles )
{
pluginLifecycle.stop();
}
}
}
| false
|
community_server_src_main_java_org_neo4j_server_modules_ExtensionInitializer.java
|
2,245
|
public class DiscoveryModuleTest
{
@Rule
public Mute mute = Mute.mute( Mute.System.err, Mute.System.out );
@SuppressWarnings( "unchecked" )
@Test
public void shouldRegisterAtRootByDefault() throws Exception
{
WebServer webServer = mock( WebServer.class );
CommunityNeoServer neoServer = mock( CommunityNeoServer.class );
when( neoServer.baseUri() ).thenReturn( new URI( "http://localhost:7575" ) );
when( neoServer.getWebServer() ).thenReturn( webServer );
DiscoveryModule module = new DiscoveryModule(webServer, new SystemOutLogging() );
module.start();
verify( webServer ).addJAXRSClasses( any( List.class ), anyString(), anyCollection() );
}
}
| false
|
community_server_src_test_java_org_neo4j_server_modules_DiscoveryModuleTest.java
|
2,246
|
public class DiscoveryModule implements ServerModule
{
private static final String ROOT_PATH = "/";
private final WebServer webServer;
private final ConsoleLogger log;
public DiscoveryModule( WebServer webServer, Logging logging )
{
this.webServer = webServer;
this.log = logging.getConsoleLog( getClass() );
}
@Override
public void start()
{
webServer.addJAXRSClasses( getClassNames(), ROOT_PATH, null );
log.log( "Mounted discovery module at [%s]", ROOT_PATH );
}
private List<String> getClassNames()
{
return listFrom( DiscoveryService.class.getName() );
}
@Override
public void stop()
{
webServer.removeJAXRSClasses( getClassNames(), ROOT_PATH );
}
}
| false
|
community_server_src_main_java_org_neo4j_server_modules_DiscoveryModule.java
|
2,247
|
public class SimpleConsoleFormatter extends Formatter
{
private final PatternLayoutEncoder encoder;
public SimpleConsoleFormatter()
{
LoggerContext context = new LoggerContext();
Map<String, String> converters = new HashMap<String, String>();
converters.put("module", ModuleConverter.class.getName());
context.putObject(CoreConstants.PATTERN_RULE_REGISTRY, converters);
encoder = new PatternLayoutEncoder();
encoder.setContext(context);
encoder.setPattern("%date{yyyy-MM-dd HH:mm:ss.SSSZ,UTC} %-5level [%module] %message%n");
encoder.start();
}
/**
* Format the given LogRecord.
*
* @param record the log record to be formatted.
* @return a formatted log record
*/
@Override
public synchronized String format( LogRecord record )
{
ILoggingEvent event = new LoggingEvent(record.getLoggerName(), (Logger) LoggerFactory.getLogger(record.getLoggerName()), Level.toLevel(record.getLevel().getName()), record.getMessage(), record.getThrown(), record.getParameters());
return encoder.getLayout().doLayout(event);
/* StringBuffer sb = new StringBuffer();
// Do the timestamp formatting
date.setTime( record.getMillis() );
StringBuffer text = new StringBuffer();
formatter.format( args, text, null );
sb.append( text );
sb.append( " " );
sb.append( record.getLoggerName() );
sb.append( " " );
String message = formatMessage( record );
sb.append( record.getLevel()
.getLocalizedName() );
sb.append( ": " );
sb.append( message );
sb.append( lineSeparator );
if ( record.getThrown() != null )
{
try
{
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter( sw );
record.getThrown()
.printStackTrace( pw );
pw.close();
sb.append( sw.toString() );
}
catch ( Exception ex )
{
}
}
return sb.toString();*/
}
}
| false
|
community_server_src_main_java_org_neo4j_server_logging_SimpleConsoleFormatter.java
|
2,248
|
public class NeoLogFilter implements Filter
{
@Override
public boolean isLoggable( LogRecord logRecord )
{
String loggerName = logRecord.getLoggerName();
return loggerName.startsWith( "org.neo4j.server" )
&& !loggerName.startsWith( "org.neo4j.server.storemigration" );
}
}
| false
|
community_server_src_main_java_org_neo4j_server_logging_NeoLogFilter.java
|
2,249
|
public class JettyLoggerAdapterTest
{
@Test
public void testSafeFormat() throws Exception
{
assertEquals( "Failed to format message: ?", safeFormat( "%" ) );
assertEquals( "Failed to format message: Program?20Files", safeFormat( "Program%20Files" ) );
assertEquals( "Failed to format message: x arg1: ?", safeFormat( "x", "%" ) );
assertEquals( "Failed to format message: x arg1: y arg2: null", safeFormat( "x", "y", null ) );
}
}
| false
|
community_server_src_test_java_org_neo4j_server_logging_JettyLoggerAdapterTest.java
|
2,250
|
public class JettyLoggerAdapter implements Logger
{
private static final String SYSTEM = "SYSTEM";
private final Logging logging;
private final StringLogger logger;
public JettyLoggerAdapter( Logging logging )
{
this.logging = logging;
this.logger = StringLogger.SYSTEM;
}
private JettyLoggerAdapter( Logging logging, StringLogger logger )
{
this.logging = logging;
this.logger = logger;
}
@Override
public void debug( Throwable arg1 )
{
logger.debug( arg1.getMessage(), arg1 );
}
@Override
public void debug( String arg0, Throwable arg1 )
{
try
{
logger.debug( wrapNull( arg0 ), arg1 );
}
catch ( IllegalFormatException e )
{
logger.debug( safeFormat( arg0, arg1 ) );
}
}
@Override
public void debug( String arg0, Object... args )
{
try
{
logger.debug( format( wrapNull( arg0 ), args ) );
}
catch ( IllegalFormatException e )
{
logger.debug( safeFormat( arg0, args ) );
}
}
@Override
public Logger getLogger( String arg0 )
{
Class<?> cls = null;
try
{
cls = Class.forName( arg0 );
}
catch ( ClassNotFoundException e )
{
cls = JettyLoggerAdapter.class;
}
return new JettyLoggerAdapter( logging, logging.getMessagesLog( cls ) );
}
@Override
public void info( String arg0, Object... args )
{
try
{
logger.info( format( wrapNull( arg0 ), args ) );
}
catch ( IllegalFormatException e )
{
logger.info( safeFormat( arg0, args ) );
}
}
@Override
public void info( Throwable arg1 )
{
logger.debug( arg1.getMessage(), arg1 );
}
@Override
public void info( String arg0, Throwable arg1 )
{
logger.debug( arg0, arg1 );
}
@Override
public boolean isDebugEnabled()
{
return true;
}
@Override
public void setDebugEnabled( boolean arg0 )
{
}
@Override
public void warn( Throwable arg1 )
{
logger.debug( arg1.getMessage(), arg1 );
}
@Override
public void warn( String arg0, Throwable arg1 )
{
// no need to catch IllegalFormatException as the delegate will use an empty message
logger.warn( wrapNull( arg1 ) );
}
@Override
public void warn( String arg0, Object... args )
{
try
{
logger.warn( format( wrapNull( arg0 ), args ) );
}
catch ( IllegalFormatException e )
{
logger.warn( safeFormat( arg0, args ) );
}
}
static String safeFormat( String arg0, Object... args )
{
StringBuilder builder = new StringBuilder();
builder.append( "Failed to format message: " );
builder.append( armored( arg0 ) );
if ( null != args )
{
for ( int i = 0; i < args.length; i++ )
{
appendArg( builder, i + 1, args[i] );
}
}
return builder.toString();
}
private static String armored( Object arg0 )
{
return wrapNull( arg0 ).replaceAll( "%", "?" );
}
private static void appendArg( StringBuilder builder, int argNum, Object arg )
{
builder.append( " arg" );
builder.append( argNum );
builder.append( ": " );
builder.append( armored( arg ) );
}
private static String wrapNull( Object arg0 )
{
return null == arg0 ? "null" : arg0.toString();
}
@Override
public void ignore( Throwable arg1 )
{
logger.debug( arg1.getMessage(), arg1 );
}
@Override
public String getName() {
return SYSTEM;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_logging_JettyLoggerAdapter.java
|
2,251
|
public class Transactor
{
private final org.neo4j.server.helpers.UnitOfWork unitOfWork;
private final GraphDatabaseService graphDb;
public Transactor( GraphDatabaseService graphDb, UnitOfWork unitOfWork )
{
this.unitOfWork = unitOfWork;
this.graphDb = graphDb;
}
public void execute()
{
Transaction tx = graphDb.beginTx();
try
{
unitOfWork.doWork();
tx.success();
}
finally
{
tx.finish();
}
}
}
| false
|
community_server_src_test_java_org_neo4j_server_helpers_Transactor.java
|
2,252
|
private static class DeleteAllSchema implements UnitOfWork
{
private final GraphDatabaseAPI db;
public DeleteAllSchema( GraphDatabaseAPI db )
{
this.db = db;
}
@Override
public void doWork()
{
deleteAllIndexRules();
deleteAllConstraints();
}
private void deleteAllIndexRules()
{
for ( IndexDefinition index : db.schema().getIndexes() )
{
if ( !index.isConstraintIndex() )
{
index.drop();
}
}
}
private void deleteAllConstraints()
{
for ( ConstraintDefinition constraint : db.schema().getConstraints() )
{
constraint.drop();
}
}
}
| false
|
community_server_src_test_java_org_neo4j_server_helpers_ServerHelper.java
|
2,253
|
private static class DeleteAllData implements UnitOfWork
{
private final GraphDatabaseAPI db;
public DeleteAllData( GraphDatabaseAPI db )
{
this.db = db;
}
@Override
public void doWork()
{
deleteAllNodesAndRelationships();
deleteAllIndexes();
}
private void deleteAllNodesAndRelationships()
{
Iterable<Node> allNodes = GlobalGraphOperations.at( db ).getAllNodes();
for ( Node n : allNodes )
{
Iterable<Relationship> relationships = n.getRelationships();
for ( Relationship rel : relationships )
{
rel.delete();
}
n.delete();
}
}
private void deleteAllIndexes()
{
IndexManager indexManager = db.index();
for ( String indexName : indexManager.nodeIndexNames() )
{
try
{
db.index()
.forNodes( indexName )
.delete();
}
catch ( UnsupportedOperationException e )
{
// Encountered a read-only index.
}
}
for ( String indexName : indexManager.relationshipIndexNames() )
{
try
{
db.index()
.forRelationships( indexName )
.delete();
}
catch ( UnsupportedOperationException e )
{
// Encountered a read-only index.
}
}
for ( String k : indexManager.getNodeAutoIndexer().getAutoIndexedProperties() )
{
indexManager.getNodeAutoIndexer().stopAutoIndexingProperty( k );
}
indexManager.getNodeAutoIndexer().setEnabled( false );
for ( String k : indexManager.getRelationshipAutoIndexer().getAutoIndexedProperties() )
{
indexManager.getRelationshipAutoIndexer().stopAutoIndexingProperty( k );
}
indexManager.getRelationshipAutoIndexer().setEnabled( false );
}
}
| false
|
community_server_src_test_java_org_neo4j_server_helpers_ServerHelper.java
|
2,254
|
public class ServerHelper
{
public static void cleanTheDatabase( final NeoServer server )
{
if ( server == null )
{
return;
}
rollbackAllOpenTransactions( server );
cleanTheDatabase( server.getDatabase().getGraph() );
removeLogs( server );
}
public static void cleanTheDatabase( GraphDatabaseAPI db )
{
new Transactor( db, new DeleteAllData( db ) ).execute();
new Transactor( db, new DeleteAllSchema( db ) ).execute();
}
private static void removeLogs( NeoServer server )
{
File logDir = new File( server.getDatabase().getLocation() + File.separator + ".." + File.separator + "log" );
try
{
FileUtils.deleteDirectory( logDir );
}
catch ( IOException e )
{
throw new RuntimeException( e );
}
}
public static NeoServer createNonPersistentServer() throws IOException
{
return createServer( CommunityServerBuilder.server(), false, null );
}
public static NeoServer createNonPersistentServer( Logging logging ) throws IOException
{
return createServer( CommunityServerBuilder.server( logging ), false, null );
}
public static NeoServer createPersistentServer( File path ) throws IOException
{
return createServer( CommunityServerBuilder.server(), true, path );
}
public static NeoServer createPersistentServer(File path, Logging logging) throws IOException
{
return createServer( CommunityServerBuilder.server( logging ), true, path );
}
private static NeoServer createServer( CommunityServerBuilder builder, boolean persistent, File path )
throws IOException
{
configureHostname( builder );
if ( persistent )
{
builder = builder.persistent();
}
NeoServer server = builder
.usingDatabaseDir( path != null ? path.getAbsolutePath() : null )
.build();
checkServerCanStart( server.baseUri().getHost(), server.baseUri().getPort() );
server.start();
return server;
}
private static void checkServerCanStart( String host, int port ) throws IOException
{
ServerSocket serverSocket = null;
try
{
serverSocket = new ServerSocket( port, 1, InetAddress.getByName( host ) );
}
catch ( IOException ex )
{
throw new RuntimeException( "Unable to start server on " + host + ":" + port, ex );
}
finally
{
if ( serverSocket != null )
{
serverSocket.close();
}
}
}
private static void configureHostname( CommunityServerBuilder builder )
{
String hostName = System.getProperty( "neo-server.test.hostname" );
if ( StringUtils.isNotEmpty( hostName ) )
{
builder.onHost( hostName );
}
}
private static void rollbackAllOpenTransactions( NeoServer server )
{
server.getTransactionRegistry().rollbackAllSuspendedTransactions();
}
private static class DeleteAllData implements UnitOfWork
{
private final GraphDatabaseAPI db;
public DeleteAllData( GraphDatabaseAPI db )
{
this.db = db;
}
@Override
public void doWork()
{
deleteAllNodesAndRelationships();
deleteAllIndexes();
}
private void deleteAllNodesAndRelationships()
{
Iterable<Node> allNodes = GlobalGraphOperations.at( db ).getAllNodes();
for ( Node n : allNodes )
{
Iterable<Relationship> relationships = n.getRelationships();
for ( Relationship rel : relationships )
{
rel.delete();
}
n.delete();
}
}
private void deleteAllIndexes()
{
IndexManager indexManager = db.index();
for ( String indexName : indexManager.nodeIndexNames() )
{
try
{
db.index()
.forNodes( indexName )
.delete();
}
catch ( UnsupportedOperationException e )
{
// Encountered a read-only index.
}
}
for ( String indexName : indexManager.relationshipIndexNames() )
{
try
{
db.index()
.forRelationships( indexName )
.delete();
}
catch ( UnsupportedOperationException e )
{
// Encountered a read-only index.
}
}
for ( String k : indexManager.getNodeAutoIndexer().getAutoIndexedProperties() )
{
indexManager.getNodeAutoIndexer().stopAutoIndexingProperty( k );
}
indexManager.getNodeAutoIndexer().setEnabled( false );
for ( String k : indexManager.getRelationshipAutoIndexer().getAutoIndexedProperties() )
{
indexManager.getRelationshipAutoIndexer().stopAutoIndexingProperty( k );
}
indexManager.getRelationshipAutoIndexer().setEnabled( false );
}
}
private static class DeleteAllSchema implements UnitOfWork
{
private final GraphDatabaseAPI db;
public DeleteAllSchema( GraphDatabaseAPI db )
{
this.db = db;
}
@Override
public void doWork()
{
deleteAllIndexRules();
deleteAllConstraints();
}
private void deleteAllIndexRules()
{
for ( IndexDefinition index : db.schema().getIndexes() )
{
if ( !index.isConstraintIndex() )
{
index.drop();
}
}
}
private void deleteAllConstraints()
{
for ( ConstraintDefinition constraint : db.schema().getConstraints() )
{
constraint.drop();
}
}
}
}
| false
|
community_server_src_test_java_org_neo4j_server_helpers_ServerHelper.java
|
2,255
|
public static abstract class PropertyArray<A, T> implements Iterable<T>
{
private PropertyArray()
{
}
public abstract int length();
public abstract A getClonedArray();
public abstract Class<?> getType();
}
| false
|
community_server-api_src_main_java_org_neo4j_server_helpers_PropertyTypeDispatcher.java
|
2,256
|
{
final int size = length();
int pos = 0;
@Override
public boolean hasNext()
{
return pos < size;
}
@Override
public T next()
{
return item( pos++ );
}
@Override
public void remove()
{
throw new UnsupportedOperationException(
"Cannot remove element from primitive array." );
}
};
| false
|
community_server-api_src_main_java_org_neo4j_server_helpers_PropertyTypeDispatcher.java
|
2,257
|
private static abstract class PrimitiveArray<A, T> extends PropertyArray<A, T>
{
@Override
public Iterator<T> iterator()
{
return new Iterator<T>()
{
final int size = length();
int pos = 0;
@Override
public boolean hasNext()
{
return pos < size;
}
@Override
public T next()
{
return item( pos++ );
}
@Override
public void remove()
{
throw new UnsupportedOperationException(
"Cannot remove element from primitive array." );
}
};
}
protected abstract T item( int offset );
}
| false
|
community_server-api_src_main_java_org_neo4j_server_helpers_PropertyTypeDispatcher.java
|
2,258
|
public class SecurityRulesModule implements ServerModule
{
private final WebServer webServer;
private final Configuration config;
private final ConsoleLogger log;
private SecurityFilter mountedFilter;
public SecurityRulesModule( WebServer webServer, Configuration config, Logging logging )
{
this.webServer = webServer;
this.config = config;
this.log = logging.getConsoleLog( getClass() );
}
@Override
public void start()
{
Iterable<SecurityRule> securityRules = getSecurityRules();
mountedFilter = new SecurityFilter( securityRules );
webServer.addFilter( mountedFilter, "/*" );
for ( SecurityRule rule : securityRules )
{
log.log( "Security rule [%s] installed on server",
rule.getClass().getCanonicalName() );
}
}
@Override
public void stop()
{
if ( mountedFilter != null )
{
mountedFilter.destroy();
}
}
private Iterable<SecurityRule> getSecurityRules()
{
ArrayList<SecurityRule> rules = new ArrayList<SecurityRule>();
for ( String classname : config.getStringArray( Configurator.SECURITY_RULES_KEY ) )
{
try
{
rules.add( (SecurityRule) Class.forName( classname ).newInstance() );
}
catch ( Exception e )
{
log.error( "Could not load server security rule [%s], exception details: ", classname, e.getMessage() );
e.printStackTrace();
}
}
return rules;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_modules_SecurityRulesModule.java
|
2,259
|
public class StatisticModule implements ServerModule
{
private final StatisticFilter filter;
private final WebServer webServer;
private final Configuration config;
public StatisticModule(WebServer webServer, StatisticCollector requestStatistics, Configuration config)
{
this.webServer = webServer;
this.config = config;
this.filter = new StatisticFilter( requestStatistics );
}
@Override
public void start()
{
if (isStatisticsEnabled())
{
webServer.addFilter(filter, "/*");
}
}
@Override
public void stop()
{
if (isStatisticsEnabled())
{
webServer.removeFilter(filter, "/*");
}
}
private boolean isStatisticsEnabled()
{
return config.getBoolean(WEBSERVER_ENABLE_STATISTICS_COLLECTION, false);
}
}
| false
|
community_server_src_main_java_org_neo4j_server_modules_StatisticModule.java
|
2,260
|
{
@Override
@SuppressWarnings( "boxing" )
public byte[] getClonedArray()
{
byte[] result = new byte[property.length];
for ( int i = 0; i < result.length; i++ )
result[i] = property[i];
return result;
}
}, param );
| false
|
community_server-api_src_main_java_org_neo4j_server_helpers_PropertyTypeDispatcher.java
|
2,261
|
public class ThirdPartyJAXRSModule implements ServerModule
{
private final Configurator configurator;
private final WebServer webServer;
private final ExtensionInitializer extensionInitializer;
private List<ThirdPartyJaxRsPackage> packages;
private final ConsoleLogger log;
public ThirdPartyJAXRSModule( WebServer webServer, Configurator configurator, Logging logging,
NeoServer neoServer )
{
this.webServer = webServer;
this.configurator = configurator;
this.log = logging.getConsoleLog( getClass() );
extensionInitializer = new ExtensionInitializer( neoServer );
}
@Override
public void start()
{
this.packages = configurator.getThirdpartyJaxRsPackages();
for ( ThirdPartyJaxRsPackage tpp : packages )
{
List<String> packageNames = packagesFor( tpp );
Collection<Injectable<?>> injectables = extensionInitializer.initializePackages( packageNames );
webServer.addJAXRSPackages( packageNames, tpp.getMountPoint(), injectables );
log.log( "Mounted third-party JAX-RS package [%s] at [%s]", tpp.getPackageName(), tpp.getMountPoint() );
}
}
private List<String> packagesFor( ThirdPartyJaxRsPackage tpp )
{
return listFrom( new String[] { tpp.getPackageName() } );
}
@Override
public void stop()
{
if ( packages == null )
{
return;
}
for ( ThirdPartyJaxRsPackage tpp : packages )
{
webServer.removeJAXRSPackages( packagesFor( tpp ), tpp.getMountPoint() );
}
extensionInitializer.stop();
}
}
| false
|
community_server_src_main_java_org_neo4j_server_modules_ThirdPartyJAXRSModule.java
|
2,262
|
class NodeTypeCaster extends TypeCaster
{
@Override
Object get( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getNode( graphDb, name );
}
@Override
Object[] getList( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getNodeList( graphDb, name );
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_NodeTypeCaster.java
|
2,263
|
public class MapTypeCaster extends TypeCaster
{
@Override
Object get( GraphDatabaseAPI graphDb, ParameterList parameters,
String name ) throws BadInputException
{
return parameters.getMap(name);
}
@Override
Object[] getList( GraphDatabaseAPI graphDb, ParameterList parameters,
String name ) throws BadInputException
{
// TODO Not done yet!
return null;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_MapTypeCaster.java
|
2,264
|
class LongTypeCaster extends TypeCaster
{
@Override
Object get( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getLong( name );
}
@Override
Object[] getList( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getLongList( name );
}
@Override
@SuppressWarnings( "boxing" )
long[] convert( Object[] data ) throws BadInputException
{
Long[] incoming = (Long[]) data;
long[] result = new long[incoming.length];
for ( int i = 0; i < result.length; i++ )
{
result[i] = incoming[i];
}
return result;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_LongTypeCaster.java
|
2,265
|
abstract class ListParameterExtractor extends ParameterExtractor
{
ListParameterExtractor( TypeCaster caster, Class<?> type, Parameter param, Description description )
{
super( caster, type, param, description );
}
@Override
Object extract( GraphDatabaseAPI graphDb, Object source, ParameterList parameters ) throws BadInputException
{
Object[] result = caster.getList( graphDb, parameters, name );
if ( result != null )
{
if ( type.isPrimitive() ) return caster.convert( result );
return convert( result );
}
if ( optional ) return null;
throw new IllegalArgumentException( "Mandatory argument \"" + name + "\" not supplied." );
}
abstract Object convert( Object[] result );
@Override
void describe( ParameterDescriptionConsumer consumer )
{
consumer.describeListParameter( name, type, optional, description );
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_ListParameterExtractor.java
|
2,266
|
class IntegerTypeCaster extends TypeCaster
{
@Override
Object get( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getInteger( name );
}
@Override
Object[] getList( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getIntegerList( name );
}
@Override
@SuppressWarnings( "boxing" )
int[] convert( Object[] data ) throws BadInputException
{
Integer[] incoming = (Integer[]) data;
int[] result = new int[incoming.length];
for ( int i = 0; i < result.length; i++ )
{
result[i] = incoming[i];
}
return result;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_IntegerTypeCaster.java
|
2,267
|
{
@Override
public Evaluation evaluate( Path path )
{
if ( path.length() < depth )
{
return Evaluation.INCLUDE_AND_CONTINUE;
}
else
{
return Evaluation.INCLUDE_AND_PRUNE;
}
}
} );
| false
|
community_server-plugin-test_src_test_java_org_neo4j_server_plugins_GraphCloner.java
|
2,268
|
@Description( "Clones a subgraph (an example taken from a community mailing list requirement)" )
public class GraphCloner extends ServerPlugin
{
public GraphCloner()
{
super( "GraphCloner" );
}
@PluginTarget( Node.class )
public Node clonedSubgraph( @Source Node startNode, @Parameter( name = "depth", optional = false ) Integer depth )
{
GraphDatabaseService graphDb = startNode.getGraphDatabase();
Transaction tx = graphDb.beginTx();
try
{
Traverser traverse = traverseToDepth( startNode, depth );
Iterator<Node> nodes = traverse.nodes()
.iterator();
HashMap<Node, Node> clonedNodes = cloneNodes( graphDb, nodes );
for ( Node oldNode : clonedNodes.keySet() )
{
// give me the matching new node
Node newStartNode = clonedNodes.get( oldNode );
// Now let's go through the relationships and copy them over
Iterator<Relationship> oldRelationships = oldNode.getRelationships( Direction.OUTGOING )
.iterator();
while ( oldRelationships.hasNext() )
{
Relationship oldRelationship = oldRelationships.next();
Node newEndNode = clonedNodes.get( oldRelationship.getEndNode() );
if ( newEndNode != null )
{
Relationship newRelationship = newStartNode.createRelationshipTo( newEndNode,
oldRelationship.getType() );
cloneProperties( oldRelationship, newRelationship );
}
}
}
tx.success();
return clonedNodes.get( startNode );
}
finally
{
tx.finish();
}
}
private void cloneProperties( Relationship oldRelationship, Relationship newRelationship )
{
Iterator<String> keys = oldRelationship.getPropertyKeys()
.iterator();
while ( keys.hasNext() )
{
String key = keys.next();
newRelationship.setProperty( key, oldRelationship.getProperty( key ) );
}
}
private Traverser traverseToDepth( final Node startNode, final int depth )
{
TraversalDescription traversalDescription = Traversal.description()
.expand( Traversal.expanderForAllTypes() )
.depthFirst()
.evaluator( new Evaluator()
{
@Override
public Evaluation evaluate( Path path )
{
if ( path.length() < depth )
{
return Evaluation.INCLUDE_AND_CONTINUE;
}
else
{
return Evaluation.INCLUDE_AND_PRUNE;
}
}
} );
return traversalDescription.traverse( startNode );
}
private Node cloneNodeData( GraphDatabaseService graphDb, Node node )
{
Node newNode = graphDb.createNode();
for ( String key : node.getPropertyKeys() )
{
newNode.setProperty( key, node.getProperty( key ) );
}
return newNode;
}
private HashMap<Node, Node> cloneNodes( GraphDatabaseService graphDb, Iterator<Node> nodes )
{
HashMap<Node, Node> result = new HashMap<Node, Node>();
while ( nodes.hasNext() )
{
Node next = nodes.next();
result.put( next, cloneNodeData( graphDb, next ) );
}
return result;
}
}
| false
|
community_server-plugin-test_src_test_java_org_neo4j_server_plugins_GraphCloner.java
|
2,269
|
@Description( "Here you can describe your plugin. It will show up in the description of the methods." )
public class FunctionalTestPlugin extends ServerPlugin
{
public static final String CREATE_NODE = "createNode";
public static final String GET_CONNECTED_NODES = "connected_nodes";
static String _string;
static Byte _byte;
static Character _character;
static Integer _integer;
static Short _short;
static Long _long;
static Float _float;
static Double _double;
static Boolean _boolean;
static Long optional;
static Set<String> stringSet;
static List<String> stringList;
static String[] stringArray;
public static int[] intArray;
@Name( GET_CONNECTED_NODES )
@PluginTarget( Node.class )
public Iterable<Node> getAllConnectedNodes( @Source Node start )
{
ArrayList<Node> nodes = new ArrayList<>();
try ( Transaction tx = start.getGraphDatabase().beginTx() )
{
for ( Relationship rel : start.getRelationships() )
{
nodes.add( rel.getOtherNode( start ) );
}
tx.success();
}
return nodes;
}
@PluginTarget( Node.class )
public Iterable<Relationship> getRelationshipsBetween( final @Source Node start,
final @Parameter( name = "other" ) Node end )
{
List<Relationship> result = new ArrayList<>();
try ( Transaction tx = start.getGraphDatabase().beginTx() )
{
for ( Relationship relationship : start.getRelationships() )
{
if ( relationship.getOtherNode( start ).equals( end ) )
{
result.add( relationship );
}
}
tx.success();
}
return result;
}
@PluginTarget( Node.class )
public Iterable<Relationship> createRelationships( @Source Node start,
@Parameter( name = "type" ) RelationshipType type, @Parameter( name = "nodes" ) Iterable<Node> nodes )
{
List<Relationship> result = new ArrayList<>();
try ( Transaction tx = start.getGraphDatabase().beginTx() )
{
for ( Node end : nodes )
{
result.add( start.createRelationshipTo( end, type ) );
}
tx.success();
}
return result;
}
@PluginTarget( Node.class )
public Node getThisNodeOrById( @Source Node start, @Parameter( name = "id", optional = true ) Long id )
{
optional = id;
if ( id == null )
{
return start;
}
try ( Transaction tx = start.getGraphDatabase().beginTx() )
{
Node node = start.getGraphDatabase().getNodeById( id );
tx.success();
return node;
}
}
@PluginTarget( GraphDatabaseService.class )
public Node createNode( @Source GraphDatabaseService db )
{
try ( Transaction tx = db.beginTx() )
{
Node node = db.createNode();
tx.success();
return node;
}
}
@PluginTarget( GraphDatabaseService.class )
public Node methodWithIntParam( @Source GraphDatabaseService db, @Parameter( name = "id", optional = false ) int id )
{
try ( Transaction tx = db.beginTx() )
{
Node node = db.getNodeById( id );
tx.success();
return node;
}
}
@PluginTarget( Relationship.class )
public Iterable<Node> methodOnRelationship( @Source Relationship rel )
{
try ( Transaction tx = rel.getGraphDatabase().beginTx() )
{
List<Node> nodes = Arrays.asList( rel.getNodes() );
tx.success();
return nodes;
}
}
@PluginTarget( GraphDatabaseService.class )
public Node methodWithAllParams( @Source GraphDatabaseService db,
@Parameter( name = "id", optional = false ) String a, @Parameter( name = "id2", optional = false ) Byte b,
@Parameter( name = "id3", optional = false ) Character c,
@Parameter( name = "id4", optional = false ) Short d,
@Parameter( name = "id5", optional = false ) Integer e,
@Parameter( name = "id6", optional = false ) Long f, @Parameter( name = "id7", optional = false ) Float g,
@Parameter( name = "id8", optional = false ) Double h,
@Parameter( name = "id9", optional = false ) Boolean i )
{
_string = a;
_byte = b;
_character = c;
_short = d;
_integer = e;
_long = f;
_float = g;
_double = h;
_boolean = i;
return getOrCreateANode( db );
}
@PluginTarget( GraphDatabaseService.class )
public Node methodWithSet( @Source GraphDatabaseService db,
@Parameter( name = "strings", optional = false ) Set<String> params )
{
stringSet = params;
return getOrCreateANode( db );
}
@PluginTarget( GraphDatabaseService.class )
public Node methodWithList( @Source GraphDatabaseService db,
@Parameter( name = "strings", optional = false ) List<String> params )
{
stringList = params;
return getOrCreateANode( db );
}
@PluginTarget( GraphDatabaseService.class )
public Node methodWithListAndInt( @Source GraphDatabaseService db,
@Parameter( name = "strings", optional = false ) List<String> params,
@Parameter( name = "count", optional = false ) int i )
{
stringList = params;
_integer = i;
return getOrCreateANode( db );
}
@PluginTarget( GraphDatabaseService.class )
public Node methodWithArray( @Source GraphDatabaseService db,
@Parameter( name = "strings", optional = false ) String[] params )
{
stringArray = params;
return getOrCreateANode( db );
}
@PluginTarget( GraphDatabaseService.class )
public Node methodWithIntArray( @Source GraphDatabaseService db,
@Parameter( name = "ints", optional = false ) int[] params )
{
intArray = params;
return getOrCreateANode( db );
}
@PluginTarget( GraphDatabaseService.class )
public Node methodWithOptionalArray( @Source GraphDatabaseService db,
@Parameter( name = "ints", optional = true ) int[] params )
{
intArray = params;
return getOrCreateANode( db );
}
@PluginTarget( Node.class )
public Path pathToReference( @Source Node me )
{
PathFinder<Path> finder = GraphAlgoFactory.shortestPath( Traversal.expanderForAllTypes(), 6 );
Transaction tx = me.getGraphDatabase().beginTx();
try
{
Node other;
if ( me.hasRelationship( DynamicRelationshipType.withName( "friend" ) ) )
{
other = me.getRelationships( DynamicRelationshipType.withName( "friend" ) )
.iterator()
.next()
.getOtherNode( me );
}
else
{
other = me.getGraphDatabase().createNode();
}
Path path = finder.findSinglePath( other, me );
tx.success();
return path;
}
finally
{
tx.finish();
}
}
private Node getOrCreateANode( GraphDatabaseService db )
{
try(Transaction tx = db.beginTx())
{
Node node;
try
{
node = db.getNodeById( 0l );
} catch(NotFoundException e)
{
node = db.createNode();
}
tx.success();
return node;
}
}
}
| false
|
community_server-plugin-test_src_test_java_org_neo4j_server_plugins_FunctionalTestPlugin.java
|
2,270
|
class FloatTypeCaster extends TypeCaster
{
@Override
Object get( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getFloat( name );
}
@Override
Object[] getList( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getFloatList( name );
}
@Override
@SuppressWarnings( "boxing" )
float[] convert( Object[] data ) throws BadInputException
{
Float[] incoming = (Float[]) data;
float[] result = new float[incoming.length];
for ( int i = 0; i < result.length; i++ )
{
result[i] = incoming[i];
}
return result;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_FloatTypeCaster.java
|
2,271
|
public class ExtensionListingFunctionalTest extends SharedServerTestBase
{
private static FunctionalTestHelper functionalTestHelper;
@BeforeClass
public static void setupServer() throws IOException
{
functionalTestHelper = new FunctionalTestHelper( SharedServerTestBase.server() );
}
@Before
public void cleanTheDatabase()
{
ServerHelper.cleanTheDatabase( SharedServerTestBase.server() );
}
@Test
public void datarootContainsReferenceToExtensions() throws Exception {
JaxRsResponse response = RestRequest.req().get(functionalTestHelper.dataUri());
assertThat(response.getStatus(), equalTo( 200 ));
Map<String, Object> json = JsonHelper.jsonToMap( response.getEntity() );
String extInfo = (String) json.get("extensions_info");
assertNotNull(new URI(extInfo));
response.close();
}
@Test
public void canListAllAvailableServerExtensions() throws Exception {
JaxRsResponse response = RestRequest.req().get(functionalTestHelper.extensionUri());
assertThat(response.getStatus(), equalTo( 200 ));
Map<String, Object> json = JsonHelper.jsonToMap( response.getEntity() );
assertFalse(json.isEmpty());
response.close();
}
@SuppressWarnings( "unchecked" )
@Test
public void canListExtensionMethodsForServerExtension() throws Exception {
JaxRsResponse response = RestRequest.req().get(functionalTestHelper.extensionUri());
assertThat(response.getStatus(), equalTo( 200 ));
Map<String, Object> json = JsonHelper.jsonToMap( response.getEntity() );
String refNodeService = (String) json.get(FunctionalTestPlugin.class.getSimpleName());
response.close();
response = RestRequest.req().get(refNodeService);
String result = response.getEntity();
assertThat(response.getStatus(), equalTo( 200 ));
json = JsonHelper.jsonToMap(result);
json = (Map<String, Object>) json.get("graphdb");
assertThat(json, hasKey( FunctionalTestPlugin.CREATE_NODE ));
response.close();
}
}
| false
|
community_server-plugin-test_src_test_java_org_neo4j_server_plugins_ExtensionListingFunctionalTest.java
|
2,272
|
class DoubleTypeCaster extends TypeCaster
{
@Override
Object get( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getDouble( name );
}
@Override
Object[] getList( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getDoubleList( name );
}
@Override
@SuppressWarnings( "boxing" )
double[] convert( Object[] data ) throws BadInputException
{
Double[] incoming = (Double[]) data;
double[] result = new double[incoming.length];
for ( int i = 0; i < result.length; i++ )
{
result[i] = incoming[i];
}
return result;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_DoubleTypeCaster.java
|
2,273
|
abstract class DataExtractor
{
abstract Object extract( GraphDatabaseAPI graphDb, Object source, ParameterList parameters )
throws BadInputException;
void describe( ParameterDescriptionConsumer consumer )
{
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_DataExtractor.java
|
2,274
|
public class CloneSubgraphPluginTest extends ExclusiveServerTestBase
{
private static final RelationshipType KNOWS = DynamicRelationshipType.withName( "knows" );
private static final RelationshipType WORKED_FOR = DynamicRelationshipType.withName( "worked_for" );
private static NeoServer server;
private static FunctionalTestHelper functionalTestHelper;
@BeforeClass
public static void setupServer() throws IOException
{
server = ServerHelper.createNonPersistentServer();
functionalTestHelper = new FunctionalTestHelper( server );
}
@AfterClass
public static void shutdownServer()
{
try
{
if ( server != null ) server.stop();
}
finally
{
server = null;
}
}
@Before
public void setupTheDatabase()
{
ServerHelper.cleanTheDatabase( server );
createASocialNetwork( server.getDatabase().getGraph() );
}
private Node jw;
private void createASocialNetwork( GraphDatabaseService db )
{
Transaction tx = db.beginTx();
try
{
jw = db.createNode();
jw.setProperty( "name", "jim" );
Node sp = db.createNode();
sp.setProperty( "name", "savas" );
Node bg = db.createNode();
bg.setProperty( "name", "bill" );
Node th = db.createNode();
th.setProperty( "name", "tony" );
Node rj = db.createNode();
rj.setProperty( "name", "rhodri" );
rj.setProperty( "hobby", "family" );
Node nj = db.createNode();
nj.setProperty( "name", "ned" );
nj.setProperty( "hobby", "cs" );
Node ml = db.createNode();
ml.setProperty( "name", "mark" );
Node mf = db.createNode();
mf.setProperty( "name", "martin" );
Node rp = db.createNode();
rp.setProperty( "name", "rebecca" );
Node rs = db.createNode();
rs.setProperty( "name", "roy" );
Node sc = db.createNode();
sc.setProperty( "name", "steve" );
sc.setProperty( "hobby", "cloud" );
Node sw = db.createNode();
sw.setProperty( "name", "stuart" );
sw.setProperty( "hobby", "cs" );
jw.createRelationshipTo( sp, KNOWS );
jw.createRelationshipTo( mf, KNOWS );
jw.createRelationshipTo( rj, KNOWS );
rj.createRelationshipTo( nj, KNOWS );
mf.createRelationshipTo( rp, KNOWS );
mf.createRelationshipTo( rs, KNOWS );
sp.createRelationshipTo( bg, KNOWS );
sp.createRelationshipTo( th, KNOWS );
sp.createRelationshipTo( mf, KNOWS );
sp.createRelationshipTo( ml, WORKED_FOR );
ml.createRelationshipTo( sc, KNOWS );
ml.createRelationshipTo( sw, KNOWS );
jw.setProperty( "hobby", "cs" );
sp.setProperty( "hobby", "cs" );
bg.setProperty( "hobby", "cs" );
ml.setProperty( "hobby", "cs" );
mf.setProperty( "hobby", "cs" );
rp.setProperty( "hobby", "lisp" );
rs.setProperty( "hobby", "socialism" );
th.setProperty( "hobby", "fishing" );
tx.success();
}
finally
{
tx.finish();
}
}
@Test
public void shouldAdvertiseExtenstionThatPluginCreates() throws JsonParseException, ClientHandlerException,
UniformInterfaceException
{
int originalCount = nodeCount();
// Find the start node URI from the server
JaxRsResponse response = new RestRequest().get(functionalTestHelper.dataUri() + "node/1");
String entity = response.getEntity();
Map<String, Object> map = JsonHelper.jsonToMap( entity );
HashMap<?, ?> extensionsMap = (HashMap<?, ?>) map.get( "extensions" );
assertNotNull( extensionsMap );
assertFalse( extensionsMap.isEmpty() );
final String GRAPH_CLONER_KEY = "GraphCloner";
assertTrue( extensionsMap.keySet()
.contains( GRAPH_CLONER_KEY ) );
final String CLONE_SUBGRAPH_KEY = "clonedSubgraph";
String clonedSubgraphUri = (String) ( (HashMap<?, ?>) extensionsMap.get( GRAPH_CLONER_KEY ) ).get( CLONE_SUBGRAPH_KEY );
assertNotNull( clonedSubgraphUri );
final String CLONE_DEPTH_MUCH_LARGER_THAN_THE_GRAPH = "99";
response.close();
response = new RestRequest().post( clonedSubgraphUri, "depth=" + CLONE_DEPTH_MUCH_LARGER_THAN_THE_GRAPH, MediaType.APPLICATION_FORM_URLENCODED_TYPE );
Assert.assertEquals( response.getEntity(), 200, response.getStatus() );
int doubleTheNumberOfNodes = ( originalCount * 2 );
assertEquals( doubleTheNumberOfNodes, nodeCount() );
}
private int nodeCount()
{
Transaction tx = server.getDatabase().getGraph().beginTx();
try
{
int count = 0;
for ( @SuppressWarnings("unused") Node node : GlobalGraphOperations.at( server.getDatabase().getGraph() )
.getAllNodes() )
{
count++;
}
return count;
}
finally
{
tx.finish();
}
}
}
| false
|
community_server-plugin-test_src_test_java_org_neo4j_server_plugins_CloneSubgraphPluginTest.java
|
2,275
|
class CharacterTypeCaster extends TypeCaster
{
@Override
Object get( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getCharacter( name );
}
@Override
Object[] getList( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getCharacterList( name );
}
@Override
@SuppressWarnings( "boxing" )
char[] convert( Object[] data ) throws BadInputException
{
Character[] incoming = (Character[]) data;
char[] result = new char[incoming.length];
for ( int i = 0; i < result.length; i++ )
{
result[i] = incoming[i];
}
return result;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_CharacterTypeCaster.java
|
2,276
|
class ByteTypeCaster extends TypeCaster
{
@Override
Object get( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getByte( name );
}
@Override
Object[] getList( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getByteList( name );
}
@Override
@SuppressWarnings( "boxing" )
byte[] convert( Object[] data ) throws BadInputException
{
Byte[] incoming = (Byte[]) data;
byte[] result = new byte[incoming.length];
for ( int i = 0; i < result.length; i++ )
{
result[i] = incoming[i];
}
return result;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_ByteTypeCaster.java
|
2,277
|
class BooleanTypeCaster extends TypeCaster
{
@Override
Object get( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getBoolean( name );
}
@Override
Object[] getList( GraphDatabaseAPI graphDb, ParameterList parameters, String name ) throws BadInputException
{
return parameters.getBooleanList( name );
}
@Override
@SuppressWarnings( "boxing" )
boolean[] convert( Object[] data ) throws BadInputException
{
Boolean[] incoming = (Boolean[]) data;
boolean[] result = new boolean[incoming.length];
for ( int i = 0; i < result.length; i++ )
{
result[i] = incoming[i];
}
return result;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_plugins_BooleanTypeCaster.java
|
2,278
|
public final class BadPluginInvocationException extends Exception
{
public BadPluginInvocationException( Throwable cause )
{
super( cause );
}
}
| false
|
community_server-api_src_main_java_org_neo4j_server_plugins_BadPluginInvocationException.java
|
2,279
|
public class WebAdminModule implements ServerModule
{
private static final String DEFAULT_WEB_ADMIN_PATH = "/webadmin";
private static final String DEFAULT_WEB_ADMIN_STATIC_WEB_CONTENT_LOCATION = "webadmin-html";
private final WebServer webServer;
private final ConsoleLogger log;
public WebAdminModule( WebServer webServer, Logging logging )
{
this.webServer = webServer;
this.log = logging.getConsoleLog( getClass() );
}
@Override
public void start()
{
webServer.addStaticContent( DEFAULT_WEB_ADMIN_STATIC_WEB_CONTENT_LOCATION, DEFAULT_WEB_ADMIN_PATH );
log.log( "Mounted webadmin at [%s]", DEFAULT_WEB_ADMIN_PATH );
}
@Override
public void stop()
{
webServer.removeStaticContent( DEFAULT_WEB_ADMIN_STATIC_WEB_CONTENT_LOCATION, DEFAULT_WEB_ADMIN_PATH );
}
}
| false
|
community_server_src_main_java_org_neo4j_server_modules_WebAdminModule.java
|
2,280
|
public class ThirdPartyJAXRSModuleTest
{
@Test
public void shouldReportThirdPartyPackagesAtSpecifiedMount() throws Exception
{
WebServer webServer = mock( WebServer.class );
CommunityNeoServer neoServer = mock( CommunityNeoServer.class );
when( neoServer.baseUri() ).thenReturn( new URI( "http://localhost:7575" ) );
when( neoServer.getWebServer() ).thenReturn( webServer );
when( neoServer.getDatabase() ).thenReturn( mock(Database.class));
Configurator configurator = mock( PropertyFileConfigurator.class );
List<ThirdPartyJaxRsPackage> jaxRsPackages = new ArrayList<ThirdPartyJaxRsPackage>();
String path = "/third/party/package";
jaxRsPackages.add( new ThirdPartyJaxRsPackage( "org.example.neo4j", path ) );
when( configurator.getThirdpartyJaxRsPackages() ).thenReturn( jaxRsPackages );
when( neoServer.getConfigurator() ).thenReturn( configurator );
ThirdPartyJAXRSModule module = new ThirdPartyJAXRSModule(webServer, configurator, DevNullLoggingService.DEV_NULL, neoServer );
module.start();
verify( webServer ).addJAXRSPackages( any( List.class ), anyString(), anyCollection() );
}
}
| false
|
community_server_src_test_java_org_neo4j_server_modules_ThirdPartyJAXRSModuleTest.java
|
2,281
|
private static abstract class BoxedArray<A, T> extends PropertyArray<A, T>
{
private final T[] array;
BoxedArray( T[] array )
{
this.array = array;
}
@Override
public int length()
{
return array.length;
}
@Override
public Iterator<T> iterator()
{
return new ArrayIterator<T>( array );
}
@Override
public Class<?> getType()
{
return array.getClass();
}
}
| false
|
community_server-api_src_main_java_org_neo4j_server_helpers_PropertyTypeDispatcher.java
|
2,282
|
{
@Override
public boolean[] getClonedArray()
{
return property.clone();
}
@Override
public int length()
{
return property.length;
}
@Override
@SuppressWarnings( "boxing" )
protected Boolean item( int offset )
{
return property[offset];
}
@Override
public Class<?> getType()
{
return property.getClass();
}
}, param );
| false
|
community_server-api_src_main_java_org_neo4j_server_helpers_PropertyTypeDispatcher.java
|
2,283
|
public abstract class ParameterList
{
private final Map<String, Object> data;
public ParameterList( Map<String, Object> data )
{
this.data = data;
}
private static abstract class Converter<T>
{
abstract T convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException;
abstract T[] newArray( int size );
}
private <T> T[] getList( String name, GraphDatabaseAPI graphDb,
Converter<T> converter ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
List<T> result = new ArrayList<>();
if ( value instanceof Object[] )
{
for ( Object element : (Object[]) value )
{
result.add( converter.convert( graphDb, element ) );
}
}
else if ( value instanceof Iterable<?> )
{
for ( Object element : (Iterable<?>) value )
{
result.add( converter.convert( graphDb, element ) );
}
}
else
{
throw new BadInputException( name + " is not a list" );
}
return result.toArray( converter.newArray( result.size() ) );
}
public String getString( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertString( value );
}
public String[] getStringList( String name ) throws BadInputException
{
return getList( name, null, new Converter<String>()
{
@Override
String convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertString( value );
}
@Override
String[] newArray( int size )
{
return new String[size];
}
} );
}
protected abstract String convertString( Object value )
throws BadInputException;
public Integer getInteger( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertInteger( value );
}
public Integer[] getIntegerList( String name ) throws BadInputException
{
return getList( name, null, new Converter<Integer>()
{
@Override
Integer convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertInteger( value );
}
@Override
Integer[] newArray( int size )
{
return new Integer[size];
}
} );
}
protected abstract Integer convertInteger( Object value )
throws BadInputException;
public Long getLong( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertLong( value );
}
public Long[] getLongList( String name ) throws BadInputException
{
return getList( name, null, new Converter<Long>()
{
@Override
Long convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertLong( value );
}
@Override
Long[] newArray( int size )
{
return new Long[size];
}
} );
}
protected abstract Long convertLong( Object value )
throws BadInputException;
public Byte getByte( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertByte( value );
}
public Byte[] getByteList( String name ) throws BadInputException
{
return getList( name, null, new Converter<Byte>()
{
@Override
Byte convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertByte( value );
}
@Override
Byte[] newArray( int size )
{
return new Byte[size];
}
} );
}
protected abstract Byte convertByte( Object value )
throws BadInputException;
public Character getCharacter( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertCharacter( value );
}
public Character[] getCharacterList( String name ) throws BadInputException
{
return getList( name, null, new Converter<Character>()
{
@Override
Character convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertCharacter( value );
}
@Override
Character[] newArray( int size )
{
return new Character[size];
}
} );
}
protected abstract Character convertCharacter( Object value )
throws BadInputException;
public Boolean getBoolean( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertBoolean( value );
}
public Boolean[] getBooleanList( String name ) throws BadInputException
{
return getList( name, null, new Converter<Boolean>()
{
@Override
Boolean convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertBoolean( value );
}
@Override
Boolean[] newArray( int size )
{
return new Boolean[size];
}
} );
}
protected abstract Boolean convertBoolean( Object value )
throws BadInputException;
public Short getShort( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertShort( value );
}
public Short[] getShortList( String name ) throws BadInputException
{
return getList( name, null, new Converter<Short>()
{
@Override
Short convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertShort( value );
}
@Override
Short[] newArray( int size )
{
return new Short[size];
}
} );
}
protected abstract Short convertShort( Object value )
throws BadInputException;
public Float getFloat( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertFloat( value );
}
public Float[] getFloatList( String name ) throws BadInputException
{
return getList( name, null, new Converter<Float>()
{
@Override
Float convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertFloat( value );
}
@Override
Float[] newArray( int size )
{
return new Float[size];
}
} );
}
protected abstract Float convertFloat( Object value )
throws BadInputException;
public Double getDouble( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertDouble( value );
}
public Double[] getDoubleList( String name ) throws BadInputException
{
return getList( name, null, new Converter<Double>()
{
@Override
Double convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertDouble( value );
}
@Override
Double[] newArray( int size )
{
return new Double[size];
}
} );
}
protected abstract Double convertDouble( Object value )
throws BadInputException;
public Node getNode( GraphDatabaseAPI graphDb, String name )
throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertNode( graphDb, value );
}
public Node[] getNodeList( GraphDatabaseAPI graphDb, String name )
throws BadInputException
{
return getList( name, graphDb, new Converter<Node>()
{
@Override
Node convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertNode( graphDb, value );
}
@Override
Node[] newArray( int size )
{
return new Node[size];
}
} );
}
protected abstract Node convertNode( GraphDatabaseAPI graphDb, Object value ) throws BadInputException;
public Relationship getRelationship( GraphDatabaseAPI graphDb, String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertRelationship( graphDb, value );
}
public Relationship[] getRelationshipList( GraphDatabaseAPI graphDb, String name ) throws BadInputException
{
return getList( name, graphDb, new Converter<Relationship>()
{
@Override
Relationship convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertRelationship( graphDb, value );
}
@Override
Relationship[] newArray( int size )
{
return new Relationship[size];
}
} );
}
protected abstract Relationship convertRelationship( GraphDatabaseAPI graphDb, Object value )
throws BadInputException;
public URI getUri( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value == null ) return null;
return convertURI( value );
}
public URI[] getUriList( String name ) throws BadInputException
{
return getList( name, null, new Converter<URI>()
{
@Override
URI convert( GraphDatabaseAPI graphDb, Object value )
throws BadInputException
{
return convertURI( value );
}
@Override
URI[] newArray( int size )
{
return new URI[size];
}
} );
}
protected URI convertURI( Object value ) throws BadInputException
{
try
{
return new URI( convertString( value ) );
}
catch ( URISyntaxException e )
{
throw new BadInputException( e );
}
}
public Map getMap( String name ) throws BadInputException
{
Object value = data.get( name );
if ( value instanceof Map )
{
return (Map) value;
}
else if ( value instanceof String )
{
throw new BadInputException( "Maps encoded as Strings not supported" );
}
return null;
}
}
| false
|
community_server-api_src_main_java_org_neo4j_server_plugins_ParameterList.java
|
2,284
|
private class TestCommunityNeoServer extends CommunityNeoServer
{
private final File configFile;
private TestCommunityNeoServer( Configurator propertyFileConfigurator, File configFile, Logging logging )
{
super( propertyFileConfigurator, logging );
this.configFile = configFile;
}
@Override
protected PreFlightTasks createPreflightTasks()
{
return preflightTasks;
}
@Override
protected Database createDatabase()
{
return persistent ?
new CommunityDatabase( configurator, logging ) :
new EphemeralDatabase( configurator );
}
@Override
protected DatabaseActions createDatabaseActions()
{
return createDatabaseActionsObject( database, configurator );
}
@Override
public void stop()
{
super.stop();
configFile.delete();
}
}
| false
|
community_server_src_test_java_org_neo4j_server_helpers_CommunityServerBuilder.java
|
2,285
|
{
@Override
public String getFailureMessage()
{
return "mockFailure";
}
@Override
public boolean run()
{
return false;
}
};
| false
|
community_server_src_test_java_org_neo4j_server_helpers_CommunityServerBuilder.java
|
2,286
|
{
@Override
public boolean run()
{
return false;
}
@Override
public PreflightTask failedTask()
{
return new PreflightTask()
{
@Override
public String getFailureMessage()
{
return "mockFailure";
}
@Override
public boolean run()
{
return false;
}
};
}
};
| false
|
community_server_src_test_java_org_neo4j_server_helpers_CommunityServerBuilder.java
|
2,287
|
public class CommunityServerBuilder
{
protected LoggingFactory loggingFactory;
private String portNo = "7474";
private String maxThreads = null;
protected String dbDir = null;
private String webAdminUri = "/db/manage/";
private String webAdminDataUri = "/db/data/";
protected PreFlightTasks preflightTasks;
private final HashMap<String, String> thirdPartyPackages = new HashMap<>();
private final Properties arbitraryProperties = new Properties();
private static enum WhatToDo
{
CREATE_GOOD_TUNING_FILE,
CREATE_DANGLING_TUNING_FILE_PROPERTY,
CREATE_CORRUPT_TUNING_FILE
}
private WhatToDo action;
protected Clock clock = null;
private String[] autoIndexedNodeKeys = null;
private String[] autoIndexedRelationshipKeys = null;
private String host = null;
private String[] securityRuleClassNames;
public boolean persistent;
private Boolean httpsEnabled = FALSE;
public static CommunityServerBuilder server( Logging logging )
{
return new CommunityServerBuilder( given( logging ) );
}
public static CommunityServerBuilder server()
{
return new CommunityServerBuilder( null );
}
public CommunityNeoServer build() throws IOException
{
if ( dbDir == null && persistent )
{
throw new IllegalStateException( "Must specify path" );
}
final File configFile = buildBefore();
BufferingConsoleLogger console = new BufferingConsoleLogger();
Validator validator = new Validator( new DatabaseLocationMustBeSpecifiedRule() );
Configurator configurator = new PropertyFileConfigurator( validator, configFile, console );
Logging logging = loggingFactory().create( configurator );
console.replayInto( logging.getConsoleLog( getClass() ) );
return build( configFile, configurator, logging );
}
protected CommunityNeoServer build( File configFile, Configurator configurator, Logging logging )
{
return new TestCommunityNeoServer( configurator, configFile, logging );
}
public File createPropertiesFiles() throws IOException
{
File temporaryConfigFile = createTempPropertyFile();
createPropertiesFile( temporaryConfigFile );
createTuningFile( temporaryConfigFile );
return temporaryConfigFile;
}
public CommunityServerBuilder withClock( Clock clock )
{
this.clock = clock;
return this;
}
public CommunityServerBuilder withLogging( Logging logging )
{
this.loggingFactory = given( logging );
return this;
}
private void createPropertiesFile( File temporaryConfigFile )
{
Map<String, String> properties = MapUtil.stringMap(
Configurator.MANAGEMENT_PATH_PROPERTY_KEY, webAdminUri,
Configurator.REST_API_PATH_PROPERTY_KEY, webAdminDataUri );
if ( dbDir != null )
{
properties.put( Configurator.DATABASE_LOCATION_PROPERTY_KEY, dbDir );
}
if ( portNo != null )
{
properties.put( Configurator.WEBSERVER_PORT_PROPERTY_KEY, portNo );
}
if ( host != null )
{
properties.put( Configurator.WEBSERVER_ADDRESS_PROPERTY_KEY, host );
}
if ( maxThreads != null )
{
properties.put( Configurator.WEBSERVER_MAX_THREADS_PROPERTY_KEY, maxThreads );
}
if ( thirdPartyPackages.keySet().size() > 0 )
{
properties.put( Configurator.THIRD_PARTY_PACKAGES_KEY, asOneLine( thirdPartyPackages ) );
}
if ( autoIndexedNodeKeys != null && autoIndexedNodeKeys.length > 0 )
{
properties.put( "node_auto_indexing", "true" );
String propertyKeys = org.apache.commons.lang.StringUtils.join( autoIndexedNodeKeys, "," );
properties.put( "node_keys_indexable", propertyKeys );
}
if ( autoIndexedRelationshipKeys != null && autoIndexedRelationshipKeys.length > 0 )
{
properties.put( "relationship_auto_indexing", "true" );
String propertyKeys = org.apache.commons.lang.StringUtils.join( autoIndexedRelationshipKeys, "," );
properties.put( "relationship_keys_indexable", propertyKeys );
}
if ( securityRuleClassNames != null && securityRuleClassNames.length > 0 )
{
String propertyKeys = org.apache.commons.lang.StringUtils.join( securityRuleClassNames, "," );
properties.put( Configurator.SECURITY_RULES_KEY, propertyKeys );
}
if ( httpsEnabled != null )
{
if ( httpsEnabled )
{
properties.put( Configurator.WEBSERVER_HTTPS_ENABLED_PROPERTY_KEY, "true" );
}
else
{
properties.put( Configurator.WEBSERVER_HTTPS_ENABLED_PROPERTY_KEY, "false" );
}
}
for ( Object key : arbitraryProperties.keySet() )
{
properties.put( String.valueOf( key ), String.valueOf( arbitraryProperties.get( key ) ) );
}
ServerTestUtils.writePropertiesToFile( properties, temporaryConfigFile );
}
private void createTuningFile( File temporaryConfigFile ) throws IOException
{
if ( action == WhatToDo.CREATE_GOOD_TUNING_FILE )
{
File databaseTuningPropertyFile = createTempPropertyFile();
Map<String, String> properties = MapUtil.stringMap(
"neostore.nodestore.db.mapped_memory", "25M",
"neostore.relationshipstore.db.mapped_memory", "50M",
"neostore.propertystore.db.mapped_memory", "90M",
"neostore.propertystore.db.strings.mapped_memory", "130M",
"neostore.propertystore.db.arrays.mapped_memory", "130M" );
writePropertiesToFile( properties, databaseTuningPropertyFile );
writePropertyToFile( Configurator.DB_TUNING_PROPERTY_FILE_KEY,
databaseTuningPropertyFile.getAbsolutePath(), temporaryConfigFile );
}
else if ( action == WhatToDo.CREATE_DANGLING_TUNING_FILE_PROPERTY )
{
writePropertyToFile( Configurator.DB_TUNING_PROPERTY_FILE_KEY, createTempPropertyFile().getAbsolutePath(),
temporaryConfigFile );
}
else if ( action == WhatToDo.CREATE_CORRUPT_TUNING_FILE )
{
File corruptTuningFile = trashFile();
writePropertyToFile( Configurator.DB_TUNING_PROPERTY_FILE_KEY, corruptTuningFile.getAbsolutePath(),
temporaryConfigFile );
}
}
private File trashFile() throws IOException
{
File f = createTempPropertyFile();
try ( FileWriter fstream = new FileWriter( f, true ); BufferedWriter out = new BufferedWriter( fstream ) )
{
for ( int i = 0; i < 100; i++ )
{
out.write( (int) System.currentTimeMillis() );
}
}
return f;
}
protected CommunityServerBuilder( LoggingFactory loggingFactory )
{
this.loggingFactory = loggingFactory;
}
public CommunityServerBuilder persistent()
{
this.persistent = true;
return this;
}
public CommunityServerBuilder onPort( int portNo )
{
this.portNo = String.valueOf( portNo );
return this;
}
public CommunityServerBuilder withMaxJettyThreads( int maxThreads )
{
this.maxThreads = String.valueOf( maxThreads );
return this;
}
public CommunityServerBuilder usingDatabaseDir( String dbDir )
{
this.dbDir = dbDir;
return this;
}
public CommunityServerBuilder withRelativeWebAdminUriPath( String webAdminUri )
{
try
{
URI theUri = new URI( webAdminUri );
if ( theUri.isAbsolute() )
{
this.webAdminUri = theUri.getPath();
}
else
{
this.webAdminUri = theUri.toString();
}
}
catch ( URISyntaxException e )
{
throw new RuntimeException( e );
}
return this;
}
public CommunityServerBuilder withRelativeWebDataAdminUriPath( String webAdminDataUri )
{
try
{
URI theUri = new URI( webAdminDataUri );
if ( theUri.isAbsolute() )
{
this.webAdminDataUri = theUri.getPath();
}
else
{
this.webAdminDataUri = theUri.toString();
}
}
catch ( URISyntaxException e )
{
throw new RuntimeException( e );
}
return this;
}
public CommunityServerBuilder withFailingPreflightTasks()
{
preflightTasks = new PreFlightTasks( DevNullLoggingService.DEV_NULL )
{
@Override
public boolean run()
{
return false;
}
@Override
public PreflightTask failedTask()
{
return new PreflightTask()
{
@Override
public String getFailureMessage()
{
return "mockFailure";
}
@Override
public boolean run()
{
return false;
}
};
}
};
return this;
}
public CommunityServerBuilder withDefaultDatabaseTuning()
{
action = WhatToDo.CREATE_GOOD_TUNING_FILE;
return this;
}
public CommunityServerBuilder withNonResolvableTuningFile()
{
action = WhatToDo.CREATE_DANGLING_TUNING_FILE_PROPERTY;
return this;
}
public CommunityServerBuilder withCorruptTuningFile()
{
action = WhatToDo.CREATE_CORRUPT_TUNING_FILE;
return this;
}
public CommunityServerBuilder withThirdPartyJaxRsPackage( String packageName, String mountPoint )
{
thirdPartyPackages.put( packageName, mountPoint );
return this;
}
public CommunityServerBuilder withFakeClock()
{
clock = new FakeClock();
return this;
}
public CommunityServerBuilder withAutoIndexingEnabledForNodes( String... keys )
{
autoIndexedNodeKeys = keys;
return this;
}
public CommunityServerBuilder withAutoIndexingEnabledForRelationships( String... keys )
{
autoIndexedRelationshipKeys = keys;
return this;
}
public CommunityServerBuilder onHost( String host )
{
this.host = host;
return this;
}
public CommunityServerBuilder withSecurityRules( String... securityRuleClassNames )
{
this.securityRuleClassNames = securityRuleClassNames;
return this;
}
public CommunityServerBuilder withHttpsEnabled()
{
httpsEnabled = TRUE;
return this;
}
public CommunityServerBuilder withProperty( String key, String value )
{
arbitraryProperties.put( key, value );
return this;
}
public CommunityServerBuilder withPreflightTasks( PreflightTask... tasks )
{
this.preflightTasks = new PreFlightTasks( DevNullLoggingService.DEV_NULL, tasks );
return this;
}
private LoggingFactory loggingFactory()
{
if ( loggingFactory != null )
{
return loggingFactory;
}
return persistent ? LoggingFactory.DEFAULT_LOGGING : LoggingFactory.IMPERMANENT_LOGGING;
}
protected DatabaseActions createDatabaseActionsObject( Database database, Configurator configurator )
{
Clock clockToUse = (clock != null) ? clock : SYSTEM_CLOCK;
return new DatabaseActions(
new LeaseManager( clockToUse ),
ForceMode.forced,
configurator.configuration().getBoolean(
Configurator.SCRIPT_SANDBOXING_ENABLED_KEY,
Configurator.DEFAULT_SCRIPT_SANDBOXING_ENABLED ), database.getGraph() );
}
protected File buildBefore() throws IOException
{
File configFile = createPropertiesFiles();
if ( preflightTasks == null )
{
preflightTasks = new PreFlightTasks( DevNullLoggingService.DEV_NULL )
{
@Override
public boolean run()
{
return true;
}
};
}
return configFile;
}
private class TestCommunityNeoServer extends CommunityNeoServer
{
private final File configFile;
private TestCommunityNeoServer( Configurator propertyFileConfigurator, File configFile, Logging logging )
{
super( propertyFileConfigurator, logging );
this.configFile = configFile;
}
@Override
protected PreFlightTasks createPreflightTasks()
{
return preflightTasks;
}
@Override
protected Database createDatabase()
{
return persistent ?
new CommunityDatabase( configurator, logging ) :
new EphemeralDatabase( configurator );
}
@Override
protected DatabaseActions createDatabaseActions()
{
return createDatabaseActionsObject( database, configurator );
}
@Override
public void stop()
{
super.stop();
configFile.delete();
}
}
}
| false
|
community_server_src_test_java_org_neo4j_server_helpers_CommunityServerBuilder.java
|
2,288
|
public class GuardingRequestFilter implements Filter
{
private final Guard guard;
private final int timeout;
private final Timer timer = new Timer();
public GuardingRequestFilter( final Guard guard, final int timeout )
{
this.guard = guard;
this.timeout = timeout;
}
@Override
public void init( FilterConfig filterConfig ) throws ServletException
{
}
public void doFilter( ServletRequest req, ServletResponse res, FilterChain chain ) throws ServletException, IOException
{
if ( req instanceof HttpServletRequest && res instanceof HttpServletResponse )
{
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
int timeLimit = getTimeLimit( request );
if ( timeLimit <= 0 )
{
chain.doFilter( req, res );
} else
{
guard.startTimeout( timeLimit );
try
{
chain.doFilter( req, res );
} catch ( GuardException e )
{
response.setStatus( SC_REQUEST_TIMEOUT );
} finally
{
guard.stop();
}
}
} else
{
chain.doFilter( req, res );
}
}
public void destroy()
{
timer.cancel();
}
private int getTimeLimit( HttpServletRequest request )
{
int timeLimit = timeout;
String headerValue = request.getHeader( "max-execution-time" );
if ( headerValue != null )
{
int maxHeader = Integer.parseInt( headerValue );
if ( timeLimit < 0 || (maxHeader > 0 && maxHeader < timeLimit) )
{
return maxHeader;
}
}
return timeLimit;
}
}
| false
|
community_server_src_main_java_org_neo4j_server_guard_GuardingRequestFilter.java
|
2,289
|
private class TestEnterpriseNeoServer extends EnterpriseNeoServer
{
private final File configFile;
public TestEnterpriseNeoServer( Configurator propertyFileConfigurator, File configFile, Logging logging )
{
super( propertyFileConfigurator, logging );
this.configFile = configFile;
}
@Override
protected PreFlightTasks createPreflightTasks()
{
return preflightTasks;
}
@Override
protected Database createDatabase()
{
return persistent ?
super.createDatabase() :
new EphemeralDatabase( configurator );
}
@Override
protected DatabaseActions createDatabaseActions()
{
return createDatabaseActionsObject( database, configurator );
}
@Override
public void stop()
{
super.stop();
configFile.delete();
}
}
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_helpers_EnterpriseServerBuilder.java
|
2,290
|
public class EnterpriseServerBuilder extends CommunityServerBuilder
{
protected EnterpriseServerBuilder( LoggingFactory loggingFactory )
{
super( loggingFactory );
}
public static EnterpriseServerBuilder server()
{
return server( IMPERMANENT_LOGGING );
}
public static EnterpriseServerBuilder server( LoggingFactory loggingFactory )
{
return new EnterpriseServerBuilder( loggingFactory );
}
@Override
public EnterpriseNeoServer build() throws IOException
{
return (EnterpriseNeoServer) super.build();
}
@Override
public EnterpriseNeoServer build( File configFile, Configurator configurator, Logging logging )
{
return new TestEnterpriseNeoServer( configurator, configFile, logging );
}
private class TestEnterpriseNeoServer extends EnterpriseNeoServer
{
private final File configFile;
public TestEnterpriseNeoServer( Configurator propertyFileConfigurator, File configFile, Logging logging )
{
super( propertyFileConfigurator, logging );
this.configFile = configFile;
}
@Override
protected PreFlightTasks createPreflightTasks()
{
return preflightTasks;
}
@Override
protected Database createDatabase()
{
return persistent ?
super.createDatabase() :
new EphemeralDatabase( configurator );
}
@Override
protected DatabaseActions createDatabaseActions()
{
return createDatabaseActionsObject( database, configurator );
}
@Override
public void stop()
{
super.stop();
configFile.delete();
}
}
}
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_helpers_EnterpriseServerBuilder.java
|
2,291
|
public class EnterpriseServerIT
{
@Rule
public TemporaryFolder folder = new TemporaryFolder();
@Rule
public DumpPortListenerOnNettyBindFailure dumpPorts = new DumpPortListenerOnNettyBindFailure();
@Test
public void shouldBeAbleToStartInHAMode() throws Throwable
{
// Given
File tuningFile = createNeo4jProperties();
NeoServer server = EnterpriseServerBuilder.server()
.usingDatabaseDir( folder.getRoot().getAbsolutePath() )
.withProperty( Configurator.DB_MODE_KEY, "HA" )
.withProperty( Configurator.DB_TUNING_PROPERTY_FILE_KEY, tuningFile.getAbsolutePath() )
.persistent()
.build();
try
{
server.start();
server.getDatabase();
assertThat( server.getDatabase(), is( EnterpriseDatabase.class ) );
assertThat( server.getDatabase().getGraph(), is( HighlyAvailableGraphDatabase.class ) );
Client client = Client.create();
ClientResponse r = client.resource( "http://localhost:" + DEFAULT_WEBSERVER_PORT +
"/db/manage/server/ha" ).accept( APPLICATION_JSON ).get( ClientResponse.class );
assertEquals( 200, r.getStatus() );
assertThat( r.getEntity( String.class ), containsString( "master" ) );
}
finally
{
server.stop();
}
}
private File createNeo4jProperties() throws IOException
{
File tuningFile = folder.newFile( "neo4j-test.properties" );
FileOutputStream fos = new FileOutputStream( tuningFile );
try
{
Properties neo4jProps = new Properties();
neo4jProps.put( ClusterSettings.server_id.name(), "1" );
neo4jProps.put( ClusterSettings.initial_hosts.name(), ":5001" );
neo4jProps.store( fos, "" );
return tuningFile;
}
finally
{
fos.close();
}
}
@After
public void whoListensOn5001()
{
dumpPorts.dumpListenersOn( 5001 );
}
}
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_functional_EnterpriseServerIT.java
|
2,292
|
{
@Override
public void evaluate() throws Throwable
{
try
{
base.evaluate();
}
catch ( Throwable failure )
{
for ( Throwable cause = failure; cause != null; cause = cause.getCause() )
{
if ( cause instanceof ChannelException )
{
String message = cause.getMessage();
String portString = message.substring( message.lastIndexOf( ':' ) + 1 );
int port;
try
{
port = Integer.parseInt( portString );
}
catch ( Exception e )
{
continue;
}
dumpListenersOn( port );
}
}
throw failure;
}
}
};
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_functional_DumpPortListenerOnNettyBindFailure.java
|
2,293
|
public class DumpPortListenerOnNettyBindFailure implements TestRule
{
private final PrintWriter out;
public DumpPortListenerOnNettyBindFailure()
{
this(System.err);
}
public DumpPortListenerOnNettyBindFailure( OutputStream out )
{
this( new PrintWriter( out, true ) );
}
public DumpPortListenerOnNettyBindFailure( Writer out )
{
this.out = out instanceof PrintWriter ? (PrintWriter) out : new PrintWriter( out, true );
}
@Override
public Statement apply( final Statement base, Description description )
{
if ( osIsWindows() )
{
return base; // we don't have 'lsof' on windows...
}
return new Statement()
{
@Override
public void evaluate() throws Throwable
{
try
{
base.evaluate();
}
catch ( Throwable failure )
{
for ( Throwable cause = failure; cause != null; cause = cause.getCause() )
{
if ( cause instanceof ChannelException )
{
String message = cause.getMessage();
String portString = message.substring( message.lastIndexOf( ':' ) + 1 );
int port;
try
{
port = Integer.parseInt( portString );
}
catch ( Exception e )
{
continue;
}
dumpListenersOn( port );
}
}
throw failure;
}
}
};
}
public void dumpListenersOn( int port )
{
try
{
Process lsof = new ProcessBuilder( "lsof", "-i:" + port ).redirectErrorStream( true ).start();
lsof.waitFor();
out.println( readAll( lsof.getInputStream() ) );
}
catch ( Exception e )
{
out.println( "Could not determine the process listening on :" + port );
}
}
private static String readAll( InputStream stream ) throws IOException
{
StringBuilder message = new StringBuilder();
BufferedReader err = new BufferedReader( new InputStreamReader( stream ) );
for ( String line; null != (line = err.readLine()); )
{
message.append( line ).append( '\n' );
}
err.close();
return message.toString();
}
}
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_functional_DumpPortListenerOnNettyBindFailure.java
|
2,294
|
{
@Override
public void start()
{
try
{
Thread.sleep( 1000 * 5 );
}
catch ( InterruptedException e )
{
throw new RuntimeException( e );
}
}
@Override
public void stop()
{
}
};
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_StartupTimeoutFunctionalTest.java
|
2,295
|
{
@Override
protected Iterable<ServerModule> createServerModules()
{
ServerModule slowModule = new ServerModule()
{
@Override
public void start()
{
try
{
Thread.sleep( 1000 * 5 );
}
catch ( InterruptedException e )
{
throw new RuntimeException( e );
}
}
@Override
public void stop()
{
}
};
return Arrays.asList( slowModule );
}
};
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_StartupTimeoutFunctionalTest.java
|
2,296
|
{
@Override
protected Iterable<ServerModule> createServerModules()
{
return Arrays.asList();
}
};
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_StartupTimeoutFunctionalTest.java
|
2,297
|
public class StartupTimeoutFunctionalTest
{
@Rule
public TargetDirectory.TestDirectory target = TargetDirectory.testDirForTest( getClass() );
public EnterpriseNeoServer server;
@After
public void stopServer()
{
if ( server != null )
{
server.stop();
server = null;
}
}
@Test
public void shouldTimeoutIfStartupTakesLongerThanTimeout() throws IOException
{
Configurator configurator = buildProperties();
configurator.configuration().setProperty( Configurator.STARTUP_TIMEOUT, 1 );
server = createSlowServer( configurator );
try
{
server.start();
fail( "Should have been interrupted." );
}
catch ( ServerStartupException e )
{
// ok!
}
}
@Test
public void shouldNotFailIfStartupTakesLessTimeThanTimeout() throws IOException
{
Configurator configurator = buildProperties();
configurator.configuration().setProperty( Configurator.STARTUP_TIMEOUT, 20 );
server = new EnterpriseNeoServer( configurator, DevNullLoggingService.DEV_NULL )
{
@Override
protected Iterable<ServerModule> createServerModules()
{
return Arrays.asList();
}
};
server.start();
}
@Test
public void shouldNotTimeOutIfTimeoutDisabled() throws IOException
{
Configurator configurator = buildProperties();
configurator.configuration().setProperty( Configurator.STARTUP_TIMEOUT, 0 );
server = createSlowServer( configurator );
server.start();
}
private EnterpriseNeoServer createSlowServer( Configurator configurator )
{
return new EnterpriseNeoServer( configurator, DevNullLoggingService.DEV_NULL )
{
@Override
protected Iterable<ServerModule> createServerModules()
{
ServerModule slowModule = new ServerModule()
{
@Override
public void start()
{
try
{
Thread.sleep( 1000 * 5 );
}
catch ( InterruptedException e )
{
throw new RuntimeException( e );
}
}
@Override
public void stop()
{
}
};
return Arrays.asList( slowModule );
}
};
}
private Configurator buildProperties() throws IOException
{
//noinspection ResultOfMethodCallIgnored
new File( target.directory(), "conf" ).mkdir();
Properties databaseProperties = new Properties();
String databasePropertiesFileName = new File( target.directory(), "conf/neo4j.properties" ).getAbsolutePath();
databaseProperties.setProperty( ClusterSettings.server_id.name(), "1" );
databaseProperties.setProperty( ClusterSettings.initial_hosts.name(), ":5001,:5002,:5003" );
databaseProperties.store( new FileWriter( databasePropertiesFileName ), null );
Properties serverProperties = new Properties();
String serverPropertiesFilename = new File( target.directory(), "conf/neo4j-server.properties" ).getAbsolutePath();
serverProperties.setProperty( Configurator.DATABASE_LOCATION_PROPERTY_KEY,
new File( target.directory(), "data/graph.db" ).getAbsolutePath() );
serverProperties.setProperty( Configurator.DB_TUNING_PROPERTY_FILE_KEY, databasePropertiesFileName );
serverProperties.setProperty( Configurator.NEO_SERVER_CONFIG_FILE_KEY, serverPropertiesFilename );
serverProperties.store( new FileWriter( serverPropertiesFilename ), null );
return new PropertyFileConfigurator( new File( serverPropertiesFilename ) );
}
}
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_StartupTimeoutFunctionalTest.java
|
2,298
|
public class StandaloneHaInfoFunctionalTest
{
private static EnterpriseNeoServer server;
@Before
public void before() throws IOException
{
server = createNonPersistentServer();
}
@After
public void after()
{
if ( server != null )
{
server.stop();
}
}
@Test
public void testHaDiscoveryOnStandaloneReturns403() throws Exception
{
FunctionalTestHelper helper = new FunctionalTestHelper( server );
JaxRsResponse response = RestRequest.req().get( getBasePath( helper ) );
assertEquals( SC_FORBIDDEN, response.getStatus() );
}
private String getBasePath( FunctionalTestHelper helper )
{
return helper.managementUri() + "/" + BASE_PATH;
}
@Test
public void testIsMasterOnStandaloneReturns403() throws Exception
{
FunctionalTestHelper helper = new FunctionalTestHelper( server );
JaxRsResponse response = RestRequest.req().get( getBasePath( helper ) + IS_MASTER_PATH );
assertEquals( SC_FORBIDDEN, response.getStatus() );
}
@Test
public void testIsSlaveOnStandaloneReturns403() throws Exception
{
FunctionalTestHelper helper = new FunctionalTestHelper( server );
JaxRsResponse response = RestRequest.req().get( getBasePath( helper ) + IS_SLAVE_PATH );
assertEquals( SC_FORBIDDEN, response.getStatus() );
}
@Test
public void testDiscoveryListingOnStandaloneDoesNotContainHA() throws Exception
{
FunctionalTestHelper helper = new FunctionalTestHelper( server );
JaxRsResponse response = RestRequest.req().get( helper.managementUri() );
Map<String, Object> map = JsonHelper.jsonToMap( response.getEntity() );
assertEquals( 3, ((Map) map.get( "services" )).size() );
}
}
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_StandaloneHaInfoFunctionalTest.java
|
2,299
|
public class StandaloneClusterClientTestProxy
{
public static final String START_SIGNAL = "starting";
public static void main( String[] args )
{
// This sysout will be intercepted by the parent process and will trigger
// a start of a timeout. The whole reason for this class to be here is to
// split awaiting for the process to start and actually awaiting the cluster client to start.
System.out.println( START_SIGNAL );
StandaloneClusterClient.main( args );
}
}
| false
|
enterprise_server-enterprise_src_test_java_org_neo4j_server_enterprise_StandaloneClusterClientTestProxy.java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.