diff --git a/src/docbkx/reference/heroku.xml b/src/docbkx/reference/heroku.xml new file mode 100644 index 000000000..fca99ab0c --- /dev/null +++ b/src/docbkx/reference/heroku.xml @@ -0,0 +1,181 @@ + + + + Heroku: seeding the coud + + + *To scale your apps you just add new dynos, so 'heroku scale web=2' etc... + +When your app fails to deploy on the first push, we dont automatically launch a single web dyno on a subsequent push, we should probably document that better. + +*Dynos have 500MB of physical ram available, plus much more than that in swap (Which you really never want to hit with a jvm). Your Procfile that launches java can use that in any way you like, but we do set a config var called JAVA_OPTS for you with some sensible defaults. + +So if you run 'heroku config' you will see the JAVA_OPTS var. you can use it in your Procfile like so + +#Procfile +web: java $JAVA_OPTS ....set up claspath and main class, etc... + +*For logging whatever you use should end up writing to System.out. if you are using a logging framework you should set up its appender to write to system.out (ConsoleAppender in log4j for instance) + +All stdout output is captured by our logplex log routing mesh so you can tail it by running 'heroku logs -t' or use the loggly addon or your own syslog server to capture log output for later analysis. + +*You have no limitation on the version of spring tomcat jetty netty or any other library or framework you can use. As long as it is in a public maven repo (or even a private maven repo) accessible by your build, maven will pull in the dependency and use it. + +*For ides we have both intellij and eclipse. We are working on a project that will make it much easier for tooling providers to do this type of integration, I will let you know when the details are public! + + + + The Spring Data Neo4j project support cross-store persistence, which allows for parts of the data to be + stored in a traditional JPA data store (RDBMS), and other parts in a graph store. This means that an entity + can be partially stored in e.g. MySQL, and partially stored in Neo4j. + + + This allows existing JPA-based applications to embrace NOSQL data stores for evolving certain parts + of their data model. Possible use cases include adding social networking or geospatial information to + existing applications. + +
+ Partial entities + + Partial graph persistence is achieved by restricting the Spring Data Neo4j aspects to manage only + explicitly annotated parts of the entity. Those fields will be made @Transient by the + aspect so that JPA ignores them. + + + A backing node in the graph store is only created when the entity has been assigned a JPA ID. Only + then will the association between the two stores be established. Until the entity has been persisted, + its state is just kept inside the POJO (in detached state), and then flushed to the backing graph + database on persist(). + + + The association between the two entities is maintained via a FOREIGN_ID field in the node, that + contains the JPA ID. Currently only single-value IDs are supported. The entity class can be resolved + via the TypeRepresentationStrategy that manages the Java type hierarchy within the graph + database. Given the ID and class, you can then retrieve the appropriate JPA entity for a given node. + + + The other direction is handled by indexing the Node with the FOREIGN_ID index which contains a + concatenation of the fully qualified class name of the JPA entity and the ID. The matching node + can then be found using the indexing facilities, and the two entities can be reassociated. + + + Using these mechanisms and the Spring Data Neo4j aspects, a single POJO can contain some fields + handled by JPA and others handles by Spring Data Neo4j. This also includes relationship fields persisted + in the graph database. + +
+
+ Cross-store annotations + + Cross-store persistence only requires the use of one additional annotation: @GraphProperty. + See below for details and an example. + +
+ @NodeEntity(partial = "true") + + When annotating an entity with partial = true, this marks it as a cross-store entity. + Spring Data Neo4j will thus only manage fields explicitly annotated with @GraphProperty. + +
+
+ @GraphProperty + + Fields of primitive or convertible types do not normally have to be annotated in order to be + persisted by Spring Data Neo4j. In cross-store mode, Spring Data Neo4j only + persists fields explicitly annotated with @GraphProperty. JPA will ignore these fields. + +
+
Example + + The following example is taken from the + Spring Data Neo4j examples + myrestaurants-social project: + + + Cross-store node entity + friends; + + @RelatedToVia(type = "recommends") + Iterable recommendations; + + @Temporal(TemporalType.TIMESTAMP) + @DateTimeFormat(style = "S-") + private Date birthDate; + + @ManyToMany(cascade = CascadeType.ALL) + private Set favorites; + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + @Column(name = "id") + private Long id; + + public void knows(UserAccount friend) { + relateTo(friend, "friends"); + } + + public Recommendation rate(Restaurant restaurant, int stars, String comment) { + Recommendation recommendation = relateTo(restaurant, Recommendation.class, "recommends"); + recommendation.rate(stars, comment); + return recommendation; + } + + public Iterable getRecommendations() { + return recommendations; + } +} +]]> + +
+
+
+ Configuring cross-store persistence + + Configuring cross-store persistence is done similarly to the default Spring Data Neo4j configuration. + All you need to do is to specify an entityManagerFactory in the XML namespace + config element, and Spring Data Neo4j will configure itself for cross-store use. + + + Cross-store Spring configuration + + + + + + + + + + + +]]> + + + +
+