How to get my diagram into eclipse?

[Ginxss]

Hello,

I currently have a diagram editor which uses a theia client, a java server and an EMF model.
(It is based on this example project: https://github.com/eclipse-glsp/glsp-examples/tree/master/project-templates/java-emf-theia)

I now want to be able to open my diagram in the Eclipse IDE instead of / in addition to theia.
However, I am having some trouble understanding what I need to do to make that happen.

I followed the steps in the eclipse integration repository for the workflow example (https://github.com/eclipse-glsp/glsp-eclipse-integration), which does work, but it does not help me understand why / how it works.

I would be very grateful if someone could tell me the basic steps that I need to do in order to get my diagram into the Eclipse IDE.

Thanks!

[tortmayr]

Hi @Ginxss,
unfortunately the project template for java-emf-eclipse is not available yet. If you want to you can check out an early WIP version here: eclipse-glsp/glsp-examples#152

I will try to break down the basic steps necessary to integrate your diagram editor into eclipse (using the WIP template as an example).
For this break down I assume that you are already familiar with the basics of plugin development and extensions in Eclipse.

In a nutshell a GLSP diagram editor is just a plain Eclipse Editor with an SWT browser widget. The glsp-client is bundled in a simple webapp that is served via a jetty server on a specific address. The SWT browser widget of the diagram editor than simply points to this address.

To achieve this you need to implement an new Eclipse plugin. Let´s call this plugin "editor plugin".
The editor plugin is responsible for four things:

• Defining the diagram editor
• Defining & implementing a ServerManager for your diagram language.
• Providing the Diagram DI configuration module.
• Providing the glsp-client webapp bundle

Defining the diagram editor & server manager extensions

https://github.com/eclipse-glsp/glsp-examples/blob/eclipseint/project-templates/java-emf-eclipse/glsp-server/org.eclipse.glsp.example.javaemf.editor/plugin.xml

The diagram editor is defined using the eclipse.ui.editors extension point .
There is not much to configure here. Just make sure to use the GLSPDiagramEditor base class and declare a unique id and a name.
Use the org.eclipse.glsp.ide.editor extension point to hook up your diagram editor with a server manager.
Here you have to configure three things.

• The serverManagerClass should point to your implementation of GLSPServerManager
• The editorId (i.e. the id of the previously configured editor)
• The glspId (i.e. the diagram type of your language)

Implementing the ServerManager

The ServerManager is the central component of the editor integration that provides

• The ServerModule for your language. This diagram module typically extends the module from your GLSP server implementation and bind/rebinds some additional things to make it work in the Eclipse IDE context.
• The resource url from which the server should serve the glsp-client bundle (i.e frontend app). Typically the glsp-client copies the webapp into a folder inside of editor plugin and the corresponding URL is the plugin Activator
• The glspId i.e. diagram type

The glsp-client (webapp)

The generic glsp client implementation has to be wrapped in a simple webapp and (ideally) bundled with webpack. In case of the project-template this is done in the tasklist-eclipse package. Here we build a simple webapp that connects to the glsp server via websocket.
At the end of the build step the bundled webapp is copied to the editor plugin so that it can be served to the corresponding editor.

I hope this rough breakdown is helpful for you. Please let me know if something is unclear.

[Ginxss]

@tortmayr

[tortmayr]

Oh sorry, I completely missed your follow-up question.

How exactly the server is started when I open my diagram in the runtime eclipse is still a little unclear to me, because as far as I can tell, the editor does not use the built server jar or the (Tasklist)ServerLauncher.java class.
The only thing the editor plugin knows from the server is the DiagramModule. Is the module just used somewhere internally to build the Server object that is handled by the GLSPServerManager?
I'm curious if it is possible to start the server jar externally and then just connect to it from the eclipse client.

You are correct, the editor does not start an external jar. Instead the GLSPServerManager uses the defined DiagramModule to create a server instance and exposes it via a websocket endpoint so that the client can communicate with it (https://github.com/eclipse-glsp/glsp-eclipse-integration/blob/master/server/plugins/org.eclipse.glsp.ide.editor/src/org/eclipse/glsp/ide/editor/GLSPServerManager.java#L95) . The Eclipse integration has been developed under the assumption that the GLSP Server and the diagram editor plugin are running in the same process. This allows them to directly communicate without a socket round trip. However, unfortunately this also means that you cannot use an external server jar.

The other thing is not that important and not directly related to GLSP, so feel free to ignore it. I just wanted to include it here in case you immediately know the answer:
When I start the runtime eclipse, it shows the version 21-3, even though my main eclipse is a much more up to date version. Why is that?

For testing we use a target platform that basically provides a test runtime (i.e. the Eclipse version and its depdencies/plugins) for the workflow editor example plugin. This target platform is currently configured for 21-3. -
You can read more about targetplatforms here: https://eclipsesource.com/blogs/2018/05/30/eclipse-target-platform-definition-dsl-and-generator/

[Ginxss]

@tortmayr Thanks for the clarification.

The Eclipse integration has been developed under the assumption that the GLSP Server and the diagram editor plugin are running in the same process. This allows them to directly communicate without a socket round trip. However, unfortunately this also means that you cannot use an external server jar.

I see, I did not think this could be the case, given that the whole point of GLSP is the client-server architechture and the communication between them, and that is was possible with the Theia client. Having the ability to separate the client and the server actually is quite important to me. Would there really be no way of connecting to an external server from a GLSP client in Eclipse?

[tortmayr]

I haven't had an in depth look at the code yet but I believe that the integration code is tightly coupled with the server code so this might be tricky. @planger WDYT? Is this possible with the current state of the Eclipse integration?

[planger]

I'm not sure either, I think it is possible, but for sure requires some adaptations.
The idea behind this design is -- with the help of dependency injection and the specific modules for external and Eclipse-specific servers -- to be able to address the benefits of both: sharing almost all the business logic between creating a standalone server for all other cases (VS Code, Theia, etc) and an Eclipse-based server, but still be able to run in the same process in case of Eclipse, which obviously yields advantages as you can directly access Eclipse API and share memory, etc.