Yes, a section from documentation I still have to add:

// create the session and start the process "com.sample.process"

KnowledgeBuilder kbuilder = ...

StatefulKnowledgeSession ksession = ...

ProcessInstance processInstance = ksession.startProcess("com.sample.process");


// add a new version of the process "com.sample.process2"

kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();

kbuilder.add(..., ResourceType.BPMN2);

kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());


// migrate process instance to new version

Map<String, Long> mapping = new HashMap<String, Long>();

// top level node 2 is mapped to a new node with id 3

mapping.put("2", 3L); 

// node 2, which is part of composite node 5, is mapped to a new node with id 4

mapping.put("5.2", 4L); 

WorkflowProcessInstanceUpgrader.upgradeProcessInstance(

   ksession, processInstance.getId(),

   "com.sample.process2", mapping);

I'm not sure if I understand you correctly, Kris. As far as I know, current JBPM 5 implementation allows you to deploy processes from file system alone (yes, I know Guvnor integration is in the works). So, when you overwrite the old bpmn process file with a new version, you basically lose the previous  version of the diagram. How the JBPM engine actually manages to "remember" old process definition? I haven't seen anything in the persistent storage (database).

Or is my assumption wrong and you have to deploy a new version of the process in a separate file with a different name (which actually makes the SCM versioning useless)? In that case how does the JBPM know the two are the newer and older version of the same  business process? The  name correlation is only cosmetic, isn't it? All in all, you start processes with a process id (which needs to be changed, according to your words).

I'm totally new to JBPM, so don't hesitate to send me to Drools or JBPM5 manual section where I can read more on that issue.

Okay, I have read the whole manual again. It implies (but does not say it directly) that JBPM should load the process definitions from file system at the application start via knowledge builder and then store it in memory, right? Now, when you start the particular process instance via kbase, it then saves (persists?) all the information needed to finish the proces in case something goes wrong (like server restart). Am I right?

So basically, when you upload new process definition, overwriting old file, and restart the server, all currently running (safe point) or waiting processes (on wait states, human tasks, etc) should be able to finish their work using old process definition (because the information is persisted) and all new processes will use the newly uploaded diagram?

I think an example would be very helpful here.

I support Michał Minicki. What will happen with process if server was restarted and its definition was replaced on file system? If we have processes with different versions when server was restarted?

The process engine itself doesn't really care about process versioning  directly, as far as it is concerned, two versions of the same process  definition are concidered different processes (they just have the same  name and a different version), and this probably makes sense as in  reality two different versions of the same process definitions can actually be completely different.

You should always keep a version of your process somewhere if you still need it (for example if there are still process instances executing based on the "old" definition).  So only if you make sure that all active instances of your old definition are either aborted or migrated to the newer version, you no longer need the old definition.

The process engine doesn't really care where those process definitions are stored, it just needs to be able to reload them (in case of restarting for example).  So you can use file system, a repository (like Gunvor), a database, or whatever you prefer.  If you use a simple file system, you probably want to have different files for each of the versions you're still using.  If you use a SCM system, you can probably reuse the same file as long as you can then retrieve all the versions of the process you still need.

Kris

Hi,

when I do the following steps (using JPAKnowledgeService and kbuilder takes files from META-INF directory):

• create session with kbase which includes "Process.BPMN"
• start process definition "HelloProcess"
• restore session with kbase which includes "Process.BPMN" with changed "HelloProcess" (id of process is not changed)

then new "HelloProcess" is used.

I don't understand why it is then writen in the user guide:

By default, jBPM5 uses the proceed approach, meaning that multiple versions of the same process can be deployed, but existing process instances will simply continue executing based on the process definition that was used when starting the process instance.

Hi Marie,

So what's the questions?

As the documentation and kris mention the process don't care about the version. If you change your process and keep the same id you can end up with strage behavior during runtime. It will depend on the process complexity and the changes that you apply. The engine knows the processes by the ID and if you change the process and keep the ID the engine will treat it as the old one.

The problems will start to appear when you have multiple processes instances in different stages and you change your process definition using the same ID.

My Two cents ..

Greetings.