1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package org.jbpm.pvm.internal.migration;
 
import java.util.ArrayList;
import java.util.List;
 
import org.jbpm.api.Execution;
import org.jbpm.api.ExecutionService;
import org.jbpm.api.ProcessDefinition;
import org.jbpm.api.ProcessDefinitionQuery;
import org.jbpm.api.ProcessInstance;
import org.jbpm.internal.log.Log;
import org.jbpm.pvm.internal.env.EnvironmentImpl;
import org.jbpm.pvm.internal.session.RepositorySession;
import org.jbpm.pvm.internal.util.ReflectUtil;
 
public class InstanceMigrator {
 
  private static Log log = Log.getLog(InstanceMigrator.class.getName());
 
  public static void migrateAll(ProcessDefinition processDefinition, MigrationDescriptor migrationDescriptor) {
//    String oldVersionId = getOldVersionId(processDefinition.getName());
//    ExecutionService executionService = (ExecutionService) EnvironmentImpl.getFromCurrent(ExecutionService.class);
//    ProcessInstanceQuery processInstanceQuery = executionService
//      .createProcessInstanceQuery()
//      .processDefinitionId(oldVersionId);
//    List<ProcessInstance> processInstances = processInstanceQuery.list();
    List<ProcessInstance> processInstances = getProcessInstancesToMigrate(processDefinition.getName(), migrationDescriptor);
    for (ProcessInstance processInstance : processInstances) {
      migrateInstance(processDefinition, processInstance, migrationDescriptor);
    }
  }
 
  public static void migrateInstance(
          ProcessDefinition processDefinition, 
          ProcessInstance processInstance, 
          MigrationDescriptor migrationDescriptor) {
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    for (String className : migrationDescriptor.getMigrationHandlerClassNames()) {
      try {
        Class<?> clazz = classLoader.loadClass(className);
        MigrationHandler handler = (MigrationHandler)ReflectUtil.newInstance(clazz);
        handler.migrateInstance(processDefinition, processInstance, migrationDescriptor);
      } catch (ClassNotFoundException e) {
        log.error("Class " + className + " not found on the classpath.", e);
      }
    }
    //migrateExecutions(processDefinition, processInstance, migrationDescriptor);
    // migrateSwimlanes(processInstance, migrationDescriptor);
    // migrateVariables(processInstance, migrationDescriptor);
    //logMigration(processInstance, processDefinition);
  }
 
  private static void migrateExecutions(ProcessDefinition processDefinition, Execution execution, MigrationDescriptor migrationDescriptor) {
    migrateChildExecutions(processDefinition, execution, migrationDescriptor);
//    if (!(execution instanceof ExecutionImpl) || !(processDefinition instanceof ProcessDefinitionImpl))
//      return;
//    ((ExecutionImpl)execution).setProcessDefinition((ProcessDefinitionImpl)processDefinition);
//    String oldName = ((ExecutionImpl) execution).getActivityName();
//    if (oldName == null)
//      return;
//    String newName = migrationDescriptor.getNewName(MigrationDescriptor.ACTIVITY_TYPE, oldName);
//    if (newName == null)
//      return;
//    Activity newActivity = ((ProcessDefinitionImpl) processDefinition).getActivity(newName);
//    if (newActivity != null) {
//      ((ExecutionImpl) execution).setActivity(newActivity);
//    }
  }
  
  private static void migrateChildExecutions(ProcessDefinition processDefinition, Execution execution, MigrationDescriptor migrationDescriptor) {
    for (Execution child : execution.getExecutions()) {
      migrateExecutions(processDefinition, child, migrationDescriptor);
    }
  }
 
//  private static void logMigration(ProcessInstance processInstance, ProcessDefinition processDefinition) {
//    ProcessInstanceMigration processInstanceMigrate = new ProcessInstanceMigration(processInstance, processDefinition);
//    HistoryEvent.fire(processInstanceMigrate);
//  }
  
  private static List<ProcessInstance> getProcessInstancesToMigrate(String processDefinitionName, MigrationDescriptor migrationDescriptor) {
    List<ProcessInstance> result = new ArrayList<ProcessInstance>();
    ExecutionService executionService = (ExecutionService) EnvironmentImpl.getFromCurrent(ExecutionService.class);
    List<ProcessDefinition> processesToMigrate = getProcessesToMigrate(processDefinitionName, migrationDescriptor);
    for (ProcessDefinition processDefinition : processesToMigrate) {
      result.addAll(
              executionService
                .createProcessInstanceQuery()
                .processDefinitionId(processDefinition.getId()).list());
    }
    return result;
  }
 
  private static List<ProcessDefinition> getProcessesToMigrate(String processDefinitionName, MigrationDescriptor migrationDescriptor) {
    RepositorySession repositorySession = EnvironmentImpl.getFromCurrent(RepositorySession.class);
    List<ProcessDefinition> processDefinitions = repositorySession
        .createProcessDefinitionQuery()
        .processDefinitionName(processDefinitionName)
        .orderAsc(ProcessDefinitionQuery.PROPERTY_VERSION)
        .list();
    int startIndex = calculateStartIndex(processDefinitions.size() - 1, migrationDescriptor);
    int endIndex = calculateEndIndex(processDefinitions.size() - 1, migrationDescriptor);
    if (startIndex > endIndex) startIndex = endIndex;
    return processDefinitions.subList(startIndex, endIndex);
  }
  
  private static int calculateStartIndex(int max, MigrationDescriptor migrationDescriptor) {
    int result = max - 1;
    if (migrationDescriptor.getStartVersion() != -1) {
      result = migrationDescriptor.getStartVersion() - 1;
    } else if (migrationDescriptor.getStartOffset() != -1) {
      result = max - migrationDescriptor.getStartOffset();
    }
    if (result < 0) result = 0;
    if (result > max - 1) result = max - 1;
    return result;
  }
  
  private static int calculateEndIndex(int max, MigrationDescriptor migrationDescriptor) {
    int result = max;
    if (migrationDescriptor.getEndVersion() != -1) {
      result = migrationDescriptor.getEndVersion();
    } else if (migrationDescriptor.getEndOffset() != -1) {
      result = max - migrationDescriptor.getEndOffset() + 1;
    }
    if (result < 1) result = 1;
    if (result > max - 1) result = max;
    return result;
  }
  
}