Examples with JobletProcess org.talend.designer.joblet.model.JobletProcess used on opensource projects

Example 1 with JobletProcess

use of org.talend.designer.joblet.model.JobletProcess in project tdi-studio-se by Talend.

the class JobletUtil method isJobletInput.

public boolean isJobletInput(Node connNode, IProcess2 process) {
    if (process.getProperty().getItem() instanceof JobletProcessItem) {
        JobletProcess jobletProcess = ((JobletProcessItem) process.getProperty().getItem()).getJobletProcess();
        List<JobletNode> jobletNodes = jobletProcess.getJobletNodes();
        for (JobletNode jnode : jobletNodes) {
            List list = jnode.getElementParameter();
            for (Object obj : list) {
                if (obj instanceof ElementParameterType) {
                    if (((ElementParameterType) obj).getValue().equals(connNode.getJoblet_unique_name())) {
                        return jnode.isInput();
                    }
                }
            }
        }
    }
    return false;
}

Example 2 with JobletProcess

use of org.talend.designer.joblet.model.JobletProcess in project tdi-studio-se by Talend.

the class UpgradeParameterHelper method upgradeItem.

/**
     * 
     * ggu Comment method "upgradeItem".
     * 
     * upgrade the item parameters.
     */
//$NON-NLS-1$
@SuppressWarnings("unchecked")
public static boolean upgradeItem(Item item) {
    if (item == null) {
        return false;
    }
    boolean changed = false;
    if (item instanceof ProcessItem) {
        // job
        ProcessType process = ((ProcessItem) item).getProcess();
        if (process != null) {
            ParametersType parameters = process.getParameters();
            if (parameters != null) {
                changed = upgradeMainParameters(parameters.getElementParameter());
            }
            changed = changed | upgradeNodes(process.getNode());
        }
    } else if (item instanceof JobletProcessItem) {
        // Joblet
        JobletProcess jobletProcess = ((JobletProcessItem) item).getJobletProcess();
        if (jobletProcess != null) {
            ParametersType parameters = jobletProcess.getParameters();
            if (parameters != null) {
                changed = upgradeMainParameters(parameters.getElementParameter());
            }
            changed = changed | upgradeNodes(jobletProcess.getNode());
        }
    }
    return changed;
}

Example 3 with JobletProcess

use of org.talend.designer.joblet.model.JobletProcess in project tdi-studio-se by Talend.

the class SynchronizeSchemaOnlyForPerlDemoMigrationTask method execute.

/*
     * (non-Javadoc)
     * 
     * @seeorg.talend.core.model.migration.AbstractJobMigrationTask#executeOnProcess(org.talend.core.model.properties.
     * ProcessItem)
     */
@Override
public ExecutionResult execute(Item item) {
    ProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
    try {
        boolean modified = false;
        ECodeLanguage language = LanguageManager.getCurrentLanguage();
        if (language == ECodeLanguage.PERL) {
            Project project = ProjectManager.getInstance().getProject(item);
            if (project != null && project.getTechnicalLabel().equalsIgnoreCase("TALENDDEMOSPERL")) {
                //$NON-NLS-1$
                IProcess2 process = (IProcess2) RepositoryPlugin.getDefault().getDesignerCoreService().getProcessFromItem(item);
                modified = synchronizeSchema(process);
                if (modified) {
                    ProcessType processType = process.saveXmlFile();
                    if (item instanceof ProcessItem) {
                        ((ProcessItem) item).setProcess(processType);
                    } else if (item instanceof JobletProcessItem) {
                        ((JobletProcessItem) item).setJobletProcess((JobletProcess) processType);
                    }
                    factory.save(item, true);
                    return ExecutionResult.SUCCESS_NO_ALERT;
                }
            }
        }
    } catch (Exception e) {
        ExceptionHandler.process(e);
        return ExecutionResult.FAILURE;
    }
    return ExecutionResult.NOTHING_TO_DO;
}

Example 4 with JobletProcess

use of org.talend.designer.joblet.model.JobletProcess in project tdi-studio-se by Talend.

the class AbstractPreferenceComposite method addButtonListeners.

private void addButtonListeners() {
    reloadBtn.addSelectionListener(new SelectionListener() {

        @Override
        public void widgetSelected(SelectionEvent e) {
            onReloadButtonClick();
        }

        @Override
        public void widgetDefaultSelected(SelectionEvent e) {
            widgetSelected(e);
        }
    });
    saveBtn.addSelectionListener(new SelectionListener() {

        @Override
        public void widgetSelected(SelectionEvent e) {
            onSaveButtonClick();
        }

        @Override
        public void widgetDefaultSelected(SelectionEvent e) {
            widgetSelected(e);
        }
    });
    if (hasRunJobNode(false) && needApplyToChildren()) {
        applyToChildrenJob.addSelectionListener(new SelectionListener() {

            /*
                 * (non-Javadoc)
                 * 
                 * @see
                 * org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)
                 */
            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
            }

            /*
                 * (non-Javadoc)
                 * 
                 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
                 */
            @Override
            public void widgetSelected(SelectionEvent e) {
                // zli for bug 12335
                final ProgressDialog progress = new ProgressDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell()) {

                    @Override
                    public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
                        IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
                        IEditorReference[] editorReferences = activePage.getEditorReferences();
                        CorePlugin defaultPlugin = CorePlugin.getDefault();
                        IDesignerCoreService designerCoreService = defaultPlugin.getDesignerCoreService();
                        List<IProcess2> openedProcessList = designerCoreService.getOpenedProcess(RepositoryUpdateManager.getEditors());
                        List<String> activeProcessId = new ArrayList<String>();
                        for (IProcess process : openedProcessList) {
                            activeProcessId.add(process.getId());
                        }
                        final int rate = 1 / openedProcessList.size() - activeProcessId.size();
                        for (INode runjobNode : tRunJobNodes) {
                            String id = (String) runjobNode.getElementParameter(EParameterName.PROCESS_TYPE_PROCESS.getName()).getValue();
                            String version = (String) runjobNode.getElementParameter(EParameterName.PROCESS_TYPE_VERSION.getName()).getValue();
                            if ("".equals(id) || id == null) {
                                //$NON-NLS-1$
                                MessageDialog.openWarning(getShell(), //$NON-NLS-1$
                                Messages.getString("AbstractPreferenceComposite.warning", runjobNode.getUniqueName()), Messages.getString("AbstractPreferenceComposite.jobAssigned", //$NON-NLS-1$
                                runjobNode.getUniqueName()));
                                return;
                            }
                            if (activeProcessId.contains(id)) {
                                IEditorPart activeEditorPart = activePage.getActiveEditor();
                                for (IEditorReference editorReference : editorReferences) {
                                    IEditorPart editorPart = editorReference.getEditor(false);
                                    if ((editorPart != activeEditorPart) && (editorPart instanceof MultiPageTalendEditor)) {
                                        IElement element = ((MultiPageTalendEditor) editorPart).getProcess();
                                        StatsAndLogsViewHelper.applySettings(elem, element, AbstractPreferenceComposite.this);
                                    }
                                }
                            } else {
                                try {
                                    SubProgressMonitor subMonitor = new SubProgressMonitor(monitor, 1 * UpdatesConstants.SCALE, SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK);
                                    subMonitor.beginTask(UpdatesConstants.EMPTY, 1 * rate);
                                    IRepositoryViewObject lastVersion = DesignerPlugin.getDefault().getProxyRepositoryFactory().getLastVersion(id);
                                    if (lastVersion != null) {
                                        Item item = lastVersion.getProperty().getItem();
                                        IProcess processFromItem = designerCoreService.getProcessFromItem(item);
                                        if (processFromItem instanceof Process) {
                                            Process process = (Process) processFromItem;
                                            StatsAndLogsViewHelper.applySettings(elem, process, AbstractPreferenceComposite.this);
                                            IProxyRepositoryFactory factory = defaultPlugin.getProxyRepositoryFactory();
                                            Property property = factory.getUptodateProperty(process.getProperty());
                                            process.setProperty(property);
                                            subMonitor.subTask(RepositoryUpdateManager.getUpdateJobInfor(process.getProperty()));
                                            ProcessType processType = process.saveXmlFile();
                                            Item item2 = process.getProperty().getItem();
                                            if (item2 instanceof JobletProcessItem) {
                                                ((JobletProcessItem) item2).setJobletProcess((JobletProcess) processType);
                                            } else {
                                                ((ProcessItem) item2).setProcess(processType);
                                            }
                                            factory.save(item2);
                                            subMonitor.done();
                                        }
                                    }
                                } catch (PersistenceException e1) {
                                    e1.printStackTrace();
                                } catch (IOException e2) {
                                    e2.printStackTrace();
                                }
                            }
                            applySettingsToSubJob(id, version);
                        }
                    }
                };
                try {
                    progress.executeProcess();
                } catch (InvocationTargetException e1) {
                    e1.printStackTrace();
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }

            /**
                 * yzhang Comment method "applySettingsToSubJob".
                 * 
                 * @param id
                 * @param version
                 */
            private void applySettingsToSubJob(String id, String version) {
                final ProcessItem processItem = ItemCacheManager.getProcessItem(id, version);
                if (processItem == null) {
                    return;
                }
                ProcessType processType = processItem.getProcess();
                EList<ElementParameterType> parameters = processType.getParameters().getElementParameter();
                StatsAndLogsViewHelper.applySettings(parameters, elem);
                List<NodeType> nodes = findRunJobNode(processType.getNode());
                for (NodeType nodeType : nodes) {
                    EList<ElementParameterType> list = nodeType.getElementParameter();
                    ElementParameterType idParam = getElementParameterType(list, //$NON-NLS-1$
                    PROCESS + ":" + EParameterName.PROCESS_TYPE_PROCESS.getName());
                    ElementParameterType versionParam = getElementParameterType(list, //$NON-NLS-1$
                    PROCESS + ":" + EParameterName.PROCESS_TYPE_VERSION.getName());
                    String subId = idParam.getValue();
                    String subVersion = versionParam.getValue();
                    applySettingsToSubJob(subId, subVersion);
                }
            }
        });
    }
}

Example 5 with JobletProcess

use of org.talend.designer.joblet.model.JobletProcess in project tdi-studio-se by Talend.

the class UpdateManagerUtils method doExecuteUpdates.

private static boolean doExecuteUpdates(final List<UpdateResult> results, final boolean updateAllJobs) {
    if (results == null || results.isEmpty()) {
        return false;
    }
    try {
        IWorkspaceRunnable op = new IWorkspaceRunnable() {

            @Override
            public void run(IProgressMonitor monitor) throws CoreException {
                monitor.setCanceled(false);
                int size = (results.size() * 2 + 1) * UpdatesConstants.SCALE;
                //$NON-NLS-1$
                monitor.beginTask(Messages.getString("UpdateManagerUtils.Update"), size);
                ProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
                // first list by job we need to update
                Map<String, Set<String>> jobIdToVersion = new HashMap<String, Set<String>>();
                Map<String, Boolean> jobIdClosed = new HashMap<String, Boolean>();
                for (UpdateResult result : results) {
                    // if (!result.isChecked()) {
                    // continue;
                    // }
                    String id = result.getObjectId();
                    String version = result.getObjectVersion();
                    if (id == null) {
                        if (result.getJob() != null && result.getJob() instanceof IProcess) {
                            IProcess process = (IProcess) result.getJob();
                            if (process instanceof IProcess2 && ERepositoryStatus.LOCK_BY_OTHER.equals(factory.getStatus(((IProcess2) process).getProperty().getItem()))) {
                                // file.
                                continue;
                            }
                            id = process.getId();
                            version = process.getVersion();
                            result.setObjectId(id);
                            result.setObjectVersion(version);
                        } else {
                            continue;
                        }
                    }
                    Set<String> versionList;
                    if (!jobIdToVersion.containsKey(id)) {
                        versionList = new HashSet<String>();
                        jobIdToVersion.put(id, versionList);
                    } else {
                        versionList = jobIdToVersion.get(id);
                    }
                    versionList.add(version);
                    //$NON-NLS-1$
                    jobIdClosed.put(id + " - " + version, result.isFromItem());
                }
                // now will execute updates only for the job selected depends this list.
                for (String currentId : jobIdToVersion.keySet()) {
                    for (String version : jobIdToVersion.get(currentId)) {
                        IRepositoryViewObject currentObj = null;
                        //$NON-NLS-1$
                        boolean closedItem = jobIdClosed.get(currentId + " - " + version);
                        IProcess process = null;
                        Item item = null;
                        if (closedItem) {
                            // if item is closed, then just load it.
                            boolean checkOnlyLastVersion = Boolean.parseBoolean(DesignerPlugin.getDefault().getPreferenceStore().getString(//$NON-NLS-1$
                            "checkOnlyLastVersion"));
                            try {
                                if (checkOnlyLastVersion || version == null) {
                                    currentObj = factory.getLastVersion(currentId);
                                } else {
                                    List<IRepositoryViewObject> allVersion = factory.getAllVersion(currentId);
                                    for (IRepositoryViewObject obj : allVersion) {
                                        if (obj.getVersion().equals(version)) {
                                            currentObj = obj;
                                        }
                                    }
                                }
                            } catch (PersistenceException e) {
                                ExceptionHandler.process(e);
                            }
                            if (currentObj == null) {
                                // item not found, don't do anything
                                continue;
                            }
                            item = currentObj.getProperty().getItem();
                            IDesignerCoreService designerCoreService = CorePlugin.getDefault().getDesignerCoreService();
                            if (item instanceof ProcessItem) {
                                process = designerCoreService.getProcessFromProcessItem((ProcessItem) item);
                            } else if (item instanceof JobletProcessItem) {
                                process = designerCoreService.getProcessFromJobletProcessItem((JobletProcessItem) item);
                            }
                        }
                        for (UpdateResult result : results) {
                            // }
                            if (!StringUtils.equals(currentId, result.getObjectId())) {
                                // not the current job we need to update
                                continue;
                            }
                            if (closedItem) {
                                if (result.getJob() == null) {
                                    result.setJob(process);
                                } else {
                                    process = (IProcess) result.getJob();
                                }
                                IUpdateItemType jobletContextType = UpdateManagerProviderDetector.INSTANCE.getUpdateItemType(UpdateManagerHelper.TYPE_JOBLET_CONTEXT);
                                if (process != null && jobletContextType != null && (jobletContextType.equals(result.getUpdateType()))) {
                                    if ((result.getParameter() instanceof List) && process.getContextManager() != null) {
                                        process.getContextManager().setListContext((List<IContext>) result.getParameter());
                                    }
                                }
                            }
                            // execute
                            executeUpdate(result, monitor, updateAllJobs);
                            if (closedItem) {
                                result.setJob(null);
                            }
                        }
                        boolean isTestContainer = false;
                        ITestContainerProviderService testContainerService = null;
                        if (GlobalServiceRegister.getDefault().isServiceRegistered(ITestContainerProviderService.class)) {
                            testContainerService = (ITestContainerProviderService) GlobalServiceRegister.getDefault().getService(ITestContainerProviderService.class);
                            if (testContainerService != null) {
                                isTestContainer = testContainerService.isTestContainerItem(item);
                            }
                        }
                        if (closedItem && process instanceof IProcess2) {
                            IProcess2 process2 = (IProcess2) process;
                            ProcessType processType;
                            try {
                                processType = process2.saveXmlFile(false);
                                if (isTestContainer) {
                                    testContainerService.setTestContainerProcess(processType, item);
                                } else if (item instanceof JobletProcessItem) {
                                    ((JobletProcessItem) item).setJobletProcess((JobletProcess) processType);
                                } else {
                                    ((ProcessItem) item).setProcess(processType);
                                }
                                factory.save(item);
                            } catch (IOException e) {
                                ExceptionHandler.process(e);
                            } catch (PersistenceException e) {
                                ExceptionHandler.process(e);
                            }
                        }
                        if (closedItem && !ERepositoryStatus.LOCK_BY_USER.equals(factory.getStatus(item))) {
                            // unload item from memory, but only if this one is not locked by current user.
                            try {
                                factory.unloadResources(item.getProperty());
                            } catch (PersistenceException e) {
                                ExceptionHandler.process(e);
                            }
                        }
                    }
                }
                UpdateManagerProviderDetector.INSTANCE.postUpdate(results);
                // update joblet reference
                upadateJobletReferenceInfor();
                final List<UpdateResult> tempResults = new ArrayList<UpdateResult>(results);
                // refresh
                Display.getDefault().asyncExec(new Runnable() {

                    @Override
                    public void run() {
                        refreshRelatedViewers(tempResults);
                        // hyWang add method checkandRefreshProcess for bug7248
                        checkandRefreshProcess(tempResults);
                    }
                });
                monitor.worked(1 * UpdatesConstants.SCALE);
                monitor.done();
            }
        };
        IRunnableWithProgress iRunnableWithProgress = new IRunnableWithProgress() {

            @Override
            public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
                IWorkspace workspace = ResourcesPlugin.getWorkspace();
                try {
                    ISchedulingRule schedulingRule = workspace.getRoot();
                    workspace.run(op, schedulingRule, IWorkspace.AVOID_UPDATE, monitor);
                } catch (CoreException e) {
                    throw new InvocationTargetException(e);
                }
            }
        };
        try {
            new ProgressMonitorDialog(null).run(false, false, iRunnableWithProgress);
        } catch (InvocationTargetException e) {
            ExceptionHandler.process(e);
        } catch (InterruptedException e) {
        }
        return !results.isEmpty();
    } finally {
        results.clear();
    }
}