Examples with RetryingTransactionCallback org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback used on opensource projects

Example 11 with RetryingTransactionCallback

use of org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback in project alfresco-remote-api by Alfresco.

the class PutMethod method executeImpl.

/**
 * Execute the WebDAV request
 *
 * @exception WebDAVServerException
 */
protected void executeImpl() throws WebDAVServerException, Exception {
    if (logger.isDebugEnabled()) {
        String path = getPath();
        String userName = getDAVHelper().getAuthenticationService().getCurrentUserName();
        logger.debug("Put node: \n" + "     user: " + userName + "\n" + "     path: " + path + "\n" + "noContent: " + noContent);
    }
    FileFolderService fileFolderService = getFileFolderService();
    // Get the status for the request path
    LockInfo nodeLockInfo = null;
    try {
        contentNodeInfo = getNodeForPath(getRootNodeRef(), getPath());
        // make sure that we are not trying to use a folder
        if (contentNodeInfo.isFolder()) {
            throw new WebDAVServerException(HttpServletResponse.SC_BAD_REQUEST);
        }
        nodeLockInfo = checkNode(contentNodeInfo);
        // 'Unhide' nodes hidden by us and behave as though we created them
        NodeRef contentNodeRef = contentNodeInfo.getNodeRef();
        if (fileFolderService.isHidden(contentNodeRef) && !getDAVHelper().isRenameShuffle(getPath())) {
            fileFolderService.setHidden(contentNodeRef, false);
            created = true;
        }
    } catch (FileNotFoundException e) {
        // the file doesn't exist - create it
        String[] paths = getDAVHelper().splitPath(getPath());
        try {
            FileInfo parentNodeInfo = getNodeForPath(getRootNodeRef(), paths[0]);
            // create file
            contentNodeInfo = getDAVHelper().createFile(parentNodeInfo, paths[1]);
            created = true;
        } catch (FileNotFoundException ee) {
            // bad path
            throw new WebDAVServerException(HttpServletResponse.SC_CONFLICT);
        } catch (FileExistsException ee) {
            // ALF-7079 fix, retry: it looks like concurrent access (file not found but file exists)
            throw new ConcurrencyFailureException("Concurrent access was detected.", ee);
        }
    }
    String userName = getDAVHelper().getAuthenticationService().getCurrentUserName();
    LockInfo lockInfo = getDAVLockService().getLockInfo(contentNodeInfo.getNodeRef());
    if (lockInfo != null) {
        if (lockInfo.isLocked() && !lockInfo.getOwner().equals(userName)) {
            if (logger.isDebugEnabled()) {
                String path = getPath();
                String owner = lockInfo.getOwner();
                logger.debug("Node locked: path=[" + path + "], owner=[" + owner + "], current user=[" + userName + "]");
            }
            // Indicate that the resource is locked
            throw new WebDAVServerException(WebDAV.WEBDAV_SC_LOCKED);
        }
    }
    // ALF-16808: We disable the versionable aspect if we are overwriting
    // empty content because it's probably part of a compound operation to
    // create a new single version
    boolean disabledVersioning = false;
    try {
        // Disable versioning if we are overwriting an empty file with content
        NodeRef nodeRef = contentNodeInfo.getNodeRef();
        ContentData contentData = (ContentData) getNodeService().getProperty(nodeRef, ContentModel.PROP_CONTENT);
        if ((contentData == null || contentData.getSize() == 0) && getNodeService().hasAspect(nodeRef, ContentModel.ASPECT_VERSIONABLE)) {
            getDAVHelper().getPolicyBehaviourFilter().disableBehaviour(nodeRef, ContentModel.ASPECT_VERSIONABLE);
            disabledVersioning = true;
        }
        // Access the content
        ContentWriter writer = fileFolderService.getWriter(contentNodeInfo.getNodeRef());
        // set content properties
        writer.guessMimetype(contentNodeInfo.getName());
        writer.guessEncoding();
        // Get the input stream from the request data
        InputStream is = m_request.getInputStream();
        // Write the new data to the content node
        writer.putContent(is);
        // - the node does not have any content (zero length binaries included)
        if (nodeLockInfo != null && nodeLockInfo.isExclusive() && !(ContentData.hasContent(contentData) && contentData.getSize() > 0)) {
            getNodeService().addAspect(contentNodeInfo.getNodeRef(), ContentModel.ASPECT_NO_CONTENT, null);
        }
        // Ask for the document metadata to be extracted
        Action extract = getActionService().createAction(ContentMetadataExtracter.EXECUTOR_NAME);
        if (extract != null) {
            extract.setExecuteAsynchronously(false);
            getActionService().executeAction(extract, contentNodeInfo.getNodeRef());
        }
        // from the original specified in the request, update it.
        if (m_strContentType == null || !m_strContentType.equals(writer.getMimetype())) {
            String oldMimeType = m_strContentType;
            m_strContentType = writer.getMimetype();
            if (logger.isDebugEnabled()) {
                logger.debug("Mimetype originally specified as " + oldMimeType + ", now guessed to be " + m_strContentType);
            }
        }
        // Record the uploaded file's size
        fileSize = writer.getSize();
        // Set the response status, depending if the node existed or not
        m_response.setStatus(created ? HttpServletResponse.SC_CREATED : HttpServletResponse.SC_NO_CONTENT);
    } catch (AccessDeniedException e) {
        throw new WebDAVServerException(HttpServletResponse.SC_FORBIDDEN, e);
    } catch (Throwable e) {
        // we are about to give up
        if (noContent && RetryingTransactionHelper.extractRetryCause(e) == null) {
            // remove the 0 bytes content if save operation failed or was cancelled
            final NodeRef nodeRef = contentNodeInfo.getNodeRef();
            getTransactionService().getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<String>() {

                public String execute() throws Throwable {
                    getNodeService().deleteNode(nodeRef);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Put failed. DELETE  " + getPath());
                    }
                    return null;
                }
            }, false, false);
        }
        throw new WebDAVServerException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);
    } finally {
        if (disabledVersioning) {
            getDAVHelper().getPolicyBehaviourFilter().enableBehaviour(contentNodeInfo.getNodeRef(), ContentModel.ASPECT_VERSIONABLE);
        }
    }
    postActivity();
}

Example 12 with RetryingTransactionCallback

use of org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback in project alfresco-remote-api by Alfresco.

the class PutMethod method parseRequestBody.

/**
 * Clears the aspect added by a LOCK request for a new file, so
 * that the Timer started by the LOCK request will not remove the
 * node now that the PUT request has been received. This is needed
 * for large content.
 *
 * @exception WebDAVServerException
 */
protected void parseRequestBody() throws WebDAVServerException {
    // Nothing is done with the body by this method. The body contains
    // the content it will be dealt with later.
    // This method is called ONCE just before the FIRST call to executeImpl,
    // which is in a retrying transaction so may be called many times.
    // Although this method is called just before the first executeImpl,
    // it is possible that the Thread could be interrupted before the first call
    // or between calls. However the chances are low and the consequence
    // (leaving a zero byte file) is minor.
    noContent = getTransactionService().getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Boolean>() {

        public Boolean execute() throws Throwable {
            FileInfo contentNodeInfo = null;
            try {
                contentNodeInfo = getNodeForPath(getRootNodeRef(), getPath());
                checkNode(contentNodeInfo);
                final NodeRef nodeRef = contentNodeInfo.getNodeRef();
                if (getNodeService().hasAspect(contentNodeInfo.getNodeRef(), ContentModel.ASPECT_WEBDAV_NO_CONTENT)) {
                    getNodeService().removeAspect(nodeRef, ContentModel.ASPECT_WEBDAV_NO_CONTENT);
                    if (logger.isDebugEnabled()) {
                        String path = getPath();
                        logger.debug("Put Timer DISABLE " + path);
                    }
                    return Boolean.TRUE;
                }
            } catch (FileNotFoundException e) {
            // Does not exist, so there will be no aspect.
            }
            return Boolean.FALSE;
        }
    }, false, true);
}

Example 13 with RetryingTransactionCallback

use of org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback in project alfresco-remote-api by Alfresco.

the class SSOFallbackBasicAuthenticationDriver method authenticateRequest.

@Override
public boolean authenticateRequest(ServletContext context, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
    String authHdr = request.getHeader("Authorization");
    HttpSession session = request.getSession(false);
    SessionUser user = session == null ? null : (SessionUser) session.getAttribute(userAttributeName);
    if (user == null) {
        if (authHdr != null && authHdr.length() > 5 && authHdr.substring(0, 5).equalsIgnoreCase("Basic")) {
            String basicAuth = new String(Base64.decodeBase64(authHdr.substring(5).getBytes()));
            String username = null;
            String password = null;
            int pos = basicAuth.indexOf(":");
            if (pos != -1) {
                username = basicAuth.substring(0, pos);
                password = basicAuth.substring(pos + 1);
            } else {
                username = basicAuth;
                password = "";
            }
            try {
                if (logger.isDebugEnabled())
                    logger.debug("Authenticating user '" + username + "'");
                Authorization auth = new Authorization(username, password);
                if (auth.isTicket()) {
                    authenticationService.validate(auth.getTicket());
                } else {
                    authenticationService.authenticate(username, password.toCharArray());
                }
                final RetryingTransactionCallback<SessionUser> callback = new RetryingTransactionCallback<SessionUser>() {

                    @Override
                    public SessionUser execute() throws Throwable {
                        NodeRef personNodeRef = personService.getPerson(authenticationService.getCurrentUserName());
                        String username = (String) nodeService.getProperty(personNodeRef, ContentModel.PROP_USERNAME);
                        NodeRef homeSpaceRef = (NodeRef) nodeService.getProperty(personNodeRef, ContentModel.PROP_HOMEFOLDER);
                        return new WebDAVUser(username, authenticationService.getCurrentTicket(), homeSpaceRef);
                    }
                };
                user = AuthenticationUtil.runAs(new AuthenticationUtil.RunAsWork<SessionUser>() {

                    public SessionUser doWork() throws Exception {
                        return transactionService.getRetryingTransactionHelper().doInTransaction(callback, true);
                    }
                }, AuthenticationUtil.SYSTEM_USER_NAME);
                if (logger.isDebugEnabled())
                    logger.debug("Authenticated user '" + username + "'");
                request.getSession().setAttribute(userAttributeName, user);
                return true;
            } catch (AuthenticationException ex) {
            // Do nothing, user object will be null
            }
        }
    } else {
        try {
            authenticationService.validate(user.getTicket());
            return true;
        } catch (AuthenticationException ex) {
            session.invalidate();
        }
    }
    return false;
}

Example 14 with RetryingTransactionCallback

use of org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback in project acs-community-packaging by Alfresco.

the class BaseDetailsBean method saveWorkflow.

/**
 * Saves the details of the workflow stored in workflowProperties
 * to the current node
 *
 * @return The outcome string
 */
public String saveWorkflow() {
    String outcome = "cancel";
    try {
        RetryingTransactionHelper txnHelper = Repository.getRetryingTransactionHelper(FacesContext.getCurrentInstance());
        RetryingTransactionCallback<Object> callback = new RetryingTransactionCallback<Object>() {

            public Object execute() throws Throwable {
                // firstly retrieve all the properties for the current node
                Map<QName, Serializable> updateProps = getNodeService().getProperties(getNode().getNodeRef());
                // update the simple workflow properties
                // set the approve step name
                updateProps.put(ApplicationModel.PROP_APPROVE_STEP, workflowProperties.get(SimpleWorkflowHandler.PROP_APPROVE_STEP_NAME));
                // specify whether the approve step will copy or move the content
                boolean approveMove = true;
                String approveAction = (String) workflowProperties.get(SimpleWorkflowHandler.PROP_APPROVE_ACTION);
                if (approveAction != null && approveAction.equals("copy")) {
                    approveMove = false;
                }
                updateProps.put(ApplicationModel.PROP_APPROVE_MOVE, Boolean.valueOf(approveMove));
                // create node ref representation of the destination folder
                updateProps.put(ApplicationModel.PROP_APPROVE_FOLDER, workflowProperties.get(SimpleWorkflowHandler.PROP_APPROVE_FOLDER));
                // determine whether there should be a reject step
                boolean requireReject = true;
                String rejectStepPresent = (String) workflowProperties.get(SimpleWorkflowHandler.PROP_REJECT_STEP_PRESENT);
                if (rejectStepPresent != null && rejectStepPresent.equals("no")) {
                    requireReject = false;
                }
                if (requireReject) {
                    // set the reject step name
                    updateProps.put(ApplicationModel.PROP_REJECT_STEP, workflowProperties.get(SimpleWorkflowHandler.PROP_REJECT_STEP_NAME));
                    // specify whether the reject step will copy or move the content
                    boolean rejectMove = true;
                    String rejectAction = (String) workflowProperties.get(SimpleWorkflowHandler.PROP_REJECT_ACTION);
                    if (rejectAction != null && rejectAction.equals("copy")) {
                        rejectMove = false;
                    }
                    updateProps.put(ApplicationModel.PROP_REJECT_MOVE, Boolean.valueOf(rejectMove));
                    // create node ref representation of the destination folder
                    updateProps.put(ApplicationModel.PROP_REJECT_FOLDER, workflowProperties.get(SimpleWorkflowHandler.PROP_REJECT_FOLDER));
                } else {
                    // set all the reject properties to null to signify there should
                    // be no reject step
                    updateProps.put(ApplicationModel.PROP_REJECT_STEP, null);
                    updateProps.put(ApplicationModel.PROP_REJECT_MOVE, null);
                    updateProps.put(ApplicationModel.PROP_REJECT_FOLDER, null);
                }
                // set the properties on the node
                getNodeService().setProperties(getNode().getNodeRef(), updateProps);
                return null;
            }
        };
        txnHelper.doInTransaction(callback);
        // reset the state of the current node so it reflects the changes just made
        getNode().reset();
        outcome = "finish";
    } catch (Throwable e) {
        Utils.addErrorMessage(MessageFormat.format(Application.getMessage(FacesContext.getCurrentInstance(), MSG_ERROR_UPDATE_SIMPLEWORKFLOW), e.getMessage()), e);
        ReportedException.throwIfNecessary(e);
    }
    return outcome;
}

Example 15 with RetryingTransactionCallback

use of org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback in project acs-community-packaging by Alfresco.

the class BaseDetailsBean method takeOwnership.

/**
 * Action Handler to take Ownership of the current node
 */
public void takeOwnership(final ActionEvent event) {
    final FacesContext fc = FacesContext.getCurrentInstance();
    try {
        RetryingTransactionHelper txnHelper = Repository.getRetryingTransactionHelper(FacesContext.getCurrentInstance());
        RetryingTransactionCallback<Object> callback = new RetryingTransactionCallback<Object>() {

            public Object execute() throws Throwable {
                getOwnableService().takeOwnership(getNode().getNodeRef());
                String msg = Application.getMessage(fc, MSG_SUCCESS_OWNERSHIP);
                FacesMessage facesMsg = new FacesMessage(FacesMessage.SEVERITY_INFO, msg, msg);
                String formId = Utils.getParentForm(fc, event.getComponent()).getClientId(fc);
                fc.addMessage(formId + ':' + getPropertiesPanelId(), facesMsg);
                getNode().reset();
                return null;
            }
        };
        txnHelper.doInTransaction(callback);
    } catch (Throwable e) {
        Utils.addErrorMessage(MessageFormat.format(Application.getMessage(fc, Repository.ERROR_GENERIC), e.getMessage()), e);
        ReportedException.throwIfNecessary(e);
    }
}