Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.day.cq.replication.ReplicationActionType
 *  com.day.cq.replication.ReplicationException
 *  com.day.cq.replication.Replicator
 *  com.day.crx.CRXRepository
 *  com.day.image.Layer
 *  com.day.jcr.vault.fs.api.ProgressTrackerListener
 *  com.day.jcr.vault.fs.api.ProgressTrackerListener$Mode
 *  com.day.jcr.vault.fs.io.AccessControlHandling
 *  com.day.jcr.vault.fs.io.Archive
 *  com.day.jcr.vault.fs.io.Archive$Entry
 *  com.day.jcr.vault.fs.io.ImportOptions
 *  com.day.jcr.vault.packaging.JcrPackage
 *  com.day.jcr.vault.packaging.JcrPackageDefinition
 *  com.day.jcr.vault.packaging.JcrPackageManager
 *  com.day.jcr.vault.packaging.PackageException
 *  com.day.jcr.vault.packaging.PackageId
 *  com.day.jcr.vault.packaging.PackagingService
 *  com.day.jcr.vault.packaging.VaultPackage
 *  javax.jcr.Node
 *  javax.jcr.NodeIterator
 *  javax.jcr.Property
 *  javax.jcr.Repository
 *  javax.jcr.RepositoryException
 *  javax.jcr.Session
 *  javax.servlet.ServletException
 *  javax.servlet.http.HttpServletRequest
 *  javax.servlet.http.HttpServletResponse
 *  org.apache.commons.io.FileUtils
 *  org.apache.commons.io.IOUtils
 *  org.apache.jackrabbit.util.Text
 *  org.apache.sling.api.resource.ResourceResolver
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.day.crx.packaging.impl;

import com.day.cq.replication.ReplicationActionType;
import com.day.cq.replication.ReplicationException;
import com.day.cq.replication.Replicator;
import com.day.crx.CRXRepository;
import com.day.crx.packaging.JSONResponse;
import com.day.crx.packaging.PackageShare;
import com.day.crx.packaging.PackageShareSession;
import com.day.crx.packaging.Proxy;
import com.day.crx.packaging.ProxyTracker;
import com.day.crx.packaging.gfx.GfxHelper;
import com.day.crx.packaging.gfx.ImageHelper;
import com.day.crx.packaging.gfx.ImageResource;
import com.day.crx.packaging.impl.RequestWrapper;
import com.day.crx.packaging.impl.SlingInstallerSupport;
import com.day.crx.packaging.impl.response.Response;
import com.day.image.Layer;
import com.day.jcr.vault.fs.api.ProgressTrackerListener;
import com.day.jcr.vault.fs.io.AccessControlHandling;
import com.day.jcr.vault.fs.io.Archive;
import com.day.jcr.vault.fs.io.ImportOptions;
import com.day.jcr.vault.packaging.JcrPackage;
import com.day.jcr.vault.packaging.JcrPackageDefinition;
import com.day.jcr.vault.packaging.JcrPackageManager;
import com.day.jcr.vault.packaging.PackageException;
import com.day.jcr.vault.packaging.PackageId;
import com.day.jcr.vault.packaging.PackagingService;
import com.day.jcr.vault.packaging.VaultPackage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Collection;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.jackrabbit.util.Text;
import org.apache.sling.api.resource.ResourceResolver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class J2EEPackageManager {
    private static final Logger log = LoggerFactory.getLogger(J2EEPackageManager.class);
    private final PackageShare psSvc;
    private final JcrPackageManager pkgMgr;
    private final ClassLoader hookClassLoader;
    private final Replicator replicator;
    private final SlingInstallerSupport installer;

    public J2EEPackageManager(JcrPackageManager pkgMgr, PackageShare psSvc, ClassLoader loader, Replicator replicator, SlingInstallerSupport installer) {
        this.pkgMgr = pkgMgr;
        this.psSvc = psSvc;
        this.hookClassLoader = loader;
        this.replicator = replicator;
        this.installer = installer;
    }

    private Session getSession(HttpServletRequest req) {
        ResourceResolver resolver = (ResourceResolver)req.getAttribute("org.apache.sling.auth.core.ResourceResolver");
        return (Session)resolver.adaptTo(Session.class);
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     * Unable to fully structure code
     * Enabled aggressive block sorting
     * Enabled unnecessary exception pruning
     * Enabled aggressive exception aggregation
     * Lifted jumps to return sites
     */
    protected void doPost(Response response, String path) throws ServletException, IOException {
        req = response.getServletRequest();
        resp = response.getServletResponse();
        try {
            cmd = CMD.valueOf(req.getParameter("cmd"));
        }
        catch (Exception e) {
            msg = "invalid or missing command: " + req.getParameter("cmd");
            J2EEPackageManager.log.warn(msg);
            resp.sendError(400, msg);
            return;
        }
        if (cmd == CMD.nop) {
            return;
        }
        resource = null;
        if (path.length() > 0) {
            try {
                resource = this.getSession((HttpServletRequest)req).getNode(path);
            }
            catch (RepositoryException e) {
                // empty catch block
            }
        }
        packMgr = PackagingService.getPackageManager((Session)this.getSession((HttpServletRequest)req));
        pack = null;
        response.init();
        try {
            switch (1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[cmd.ordinal()]) {
                case 1: {
                    this.createPackage(response);
                    ** break;
                }
                case 2: {
                    this.uploadPackage(response);
                    ** break;
                }
                case 3: {
                    pack = this.getPackage(packMgr, resource);
                    this.consoleBuild(packMgr, pack, response);
                    ** break;
                }
                case 4: {
                    pack = this.getPackage(packMgr, resource);
                    this.consoleContents(pack, response);
                    ** break;
                }
                case 5: {
                    pack = this.getPackage(packMgr, resource);
                    this.consoleDryRun(pack, response);
                    ** break;
                }
                case 6: {
                    pack = this.getPackage(packMgr, resource);
                    this.consoleInstall(pack, response);
                    ** break;
                }
                case 7: {
                    pack = this.getPackage(packMgr, resource);
                    this.consolePreview(pack, response);
                    ** break;
                }
                case 8: {
                    pack = this.getPackage(packMgr, resource);
                    this.consoleRewrap(packMgr, pack, response);
                    ** break;
                }
                case 9: {
                    pack = this.getPackage(packMgr, resource);
                    this.consoleShare(pack, response);
                    ** break;
                }
                case 10: {
                    pack = this.getPackage(packMgr, resource);
                    this.consoleUninstall(pack, response);
                    ** break;
                }
                case 11: {
                    pack = this.getPackage(packMgr, resource);
                    this.deletePackage(packMgr, pack, response);
                    ** break;
                }
                case 12: {
                    pack = this.getPackage(packMgr, resource);
                    this.replicatePackage(packMgr, pack, response);
                    ** break;
                }
                case 13: {
                    this.consoleShareUpload(response);
                    ** break;
                }
                case 14: {
                    this.consoleShareDownload(response);
                    ** break;
                }
                case 15: {
                    pid = PackageId.fromString((String)req.getParameter("pid"));
                    if (pid == null) {
                        msg = "invalid or missing pid parameter: " + req.getParameter("pid");
                        J2EEPackageManager.log.warn(msg);
                        resp.sendError(400, msg);
                        return;
                    }
                    this.consoleShareValidate(this.getSession((HttpServletRequest)req), pid, response);
                }
            }
        }
        catch (Throwable e) {
            response.error(e.getMessage(), e);
        }
        finally {
            if (pack != null) {
                pack.close();
            }
        }
        response.send();
    }

    private JcrPackage getPackage(JcrPackageManager packMgr, Node resource) throws RepositoryException {
        JcrPackage pack;
        JcrPackage jcrPackage = pack = resource == null ? null : packMgr.open(resource);
        if (pack == null) {
            throw new IllegalArgumentException("no package");
        }
        return pack;
    }

    private void consolePreview(JcrPackage pack, Response response) throws RepositoryException, IOException {
        response.start("Dump package coverage");
        pack.getDefinition().dumpCoverage((ProgressTrackerListener)response);
        response.success("Coverage dumped.");
    }

    private void consoleContents(JcrPackage pack, Response response) throws RepositoryException, IOException {
        response.start("Dump package contents");
        VaultPackage zvp = pack.getPackage();
        Archive archive = zvp.getArchive();
        for (Archive.Entry child : archive.getRoot().getChildren()) {
            this.consoleContents(child, "", response);
        }
        response.success("Contents dumped.");
    }

    private void consoleContents(Archive.Entry entry, String parentPath, Response response) throws RepositoryException, IOException {
        String path = parentPath + "/" + entry.getName();
        response.onMessage(null, "-", path);
        for (Archive.Entry child : entry.getChildren()) {
            this.consoleContents(child, path, response);
        }
    }

    private void consoleBuild(JcrPackageManager packMgr, JcrPackage pack, Response response) throws RepositoryException, IOException, PackageException {
        response.start("Building package");
        this.stampThumbnail(pack.getDefNode(), response);
        this.stampScreenshots(pack.getDefNode(), response);
        packMgr.assemble(pack, (ProgressTrackerListener)response);
        response.success("Package built");
    }

    private void consoleRewrap(JcrPackageManager packMgr, JcrPackage pack, Response response) throws RepositoryException, IOException, PackageException {
        response.start("Repackaging definition");
        this.stampThumbnail(pack.getDefNode(), response);
        this.stampScreenshots(pack.getDefNode(), response);
        packMgr.rewrap(pack, (ProgressTrackerListener)response);
        response.success("Definition repackaged");
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private void consoleInstall(JcrPackage pack, Response response) throws RepositoryException, IOException, PackageException {
        RequestWrapper req = response.getServletRequest();
        int as = -1;
        try {
            as = Integer.parseInt(req.getParameter("autosave"));
        }
        catch (Exception e) {
            // empty catch block
        }
        boolean recursive = "true".equals(req.getParameter("recursive"));
        AccessControlHandling acHandling = null;
        String acStr = req.getParameter("acHandling");
        if (acStr != null && acStr.length() > 0) {
            try {
                acHandling = AccessControlHandling.valueOf((String)acStr.toUpperCase());
            }
            catch (Exception e) {
                log.warn("invalid access control handling: {}", (Object)e.toString());
            }
        }
        response.start("Installing content");
        Session session = pack.getNode().getSession();
        ImportOptions opts = new ImportOptions();
        if (as >= 0) {
            opts.setAutoSaveThreshold(as);
        }
        File repoHome = null;
        try {
            repoHome = ((CRXRepository)session.getRepository()).getHomeDir();
        }
        catch (Exception e) {
            log.warn("Unable to get repository home.", (Throwable)e);
        }
        if (repoHome != null) {
            opts.setPatchDirectory(new File(repoHome, "patches/new"));
        }
        opts.setNonRecursive(!recursive);
        opts.setHookClassLoader(this.hookClassLoader);
        opts.setAccessControlHandling(acHandling);
        opts.setListener((ProgressTrackerListener)response);
        SlingInstallerSupport.Handle handle = this.installer.pause();
        try {
            pack.install(opts);
        }
        finally {
            handle.release();
        }
        if (pack.getDefinition().requiresRestart()) {
            response.setAlertMessage("Please restart the instance to complete the installation.");
        }
        response.success("Package installed");
    }

    private void consoleDryRun(JcrPackage pack, Response response) throws RepositoryException, IOException, PackageException {
        response.start("Installing content (dry run)");
        ImportOptions opts = new ImportOptions();
        opts.setListener((ProgressTrackerListener)response);
        opts.setDryRun(true);
        pack.install(opts);
        response.success("Package installed (dry run)");
    }

    private void consoleUninstall(JcrPackage pack, Response response) throws RepositoryException, IOException, PackageException {
        response.start("Uninstalling content");
        ImportOptions opts = new ImportOptions();
        opts.setListener((ProgressTrackerListener)response);
        opts.setHookClassLoader(this.hookClassLoader);
        pack.uninstall(opts);
        response.success("Package uninstalled");
    }

    private void consoleShare(JcrPackage pack, Response response) throws RepositoryException, IOException, PackageException {
        RequestWrapper req = response.getServletRequest();
        PackageShareSession s = this.psSvc.getSession((HttpServletRequest)req);
        if (s == null) {
            throw new IllegalStateException("No logged in package share");
        }
        String pid = req.getParameter("pid");
        response.start("Uploading package");
        JSONResponse resp = s.uploadPackage(pack.getNode(), response.getTracker(null, pid), null);
        response.log("%d %s", resp.getStatus(), resp.getMessage());
        response.success("Package uploaded");
    }

    private void consoleShareValidate(Session session, PackageId pid, Response response) throws RepositoryException, IOException, PackageException {
        String packagePath = pid.getInstallationPath();
        if (session.hasPermission(packagePath, "add_node")) {
            response.success("ok");
        } else {
            String msg = "User '" + session.getUserID() + "' has insufficient access rights to store package in repository. Refusing download.";
            log.warn(msg);
            response.error(msg);
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private void consoleShareUpload(Response response) throws RepositoryException, IOException {
        block7 : {
            RequestWrapper req = response.getServletRequest();
            PackageShareSession s = this.psSvc.getSession((HttpServletRequest)req);
            if (s == null) {
                throw new IllegalArgumentException("No package share session.");
            }
            String group = req.getParameter("group");
            String pid = req.getParameter("pid");
            String path = req.getParameter("path");
            String name = req.getParameter("name");
            File file = null;
            try {
                if (path == null || path.length() == 0) {
                    throw new IllegalArgumentException("path parameter missing");
                }
                if (pid == null || pid.length() == 0) {
                    pid = "upload:dummy";
                }
                file = new File(path);
                response.start("Uploading Package");
                Response.ShareTracker tracker = response.getTracker("uploading", pid);
                tracker.message("uploading", "");
                Proxy proxy = s.createProxy(false);
                proxy.setTracker(tracker);
                JSONResponse resp = s.uploadPackage(file, name, tracker, group);
                if (resp.getStatus() == 200) {
                    response.success("Package uploaded");
                    tracker.message("uploaded", "");
                    break block7;
                }
                response.error("Error during upload: " + resp.getMessage());
                tracker.message("uploadError", resp.getMessage());
            }
            finally {
                FileUtils.deleteQuietly((File)file);
            }
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private void consoleShareDownload(Response response) throws Exception {
        RequestWrapper req = response.getServletRequest();
        JcrPackage pack = null;
        Response.ShareTracker tracker = null;
        try {
            PackageShareSession s = this.psSvc.getSession((HttpServletRequest)req);
            if (s == null) {
                throw new IllegalArgumentException("No package share session.");
            }
            String pid = req.getParameter("pid");
            String url = req.getParameter("url");
            String size = req.getParameter("size");
            long len = -1;
            try {
                len = size != null ? Long.parseLong(size) : -1;
            }
            catch (NumberFormatException e) {
                // empty catch block
            }
            if (url == null || url.length() == 0) {
                throw new IllegalArgumentException("URL parameter missing");
            }
            response.start("Downloading package");
            response.log("Id: %s, Size=%d", pid, len);
            tracker = response.getTracker("downloading", pid);
            Proxy proxy = s.createProxy(false);
            proxy.setTracker(tracker);
            proxy.setFollowRedirects(true);
            File tmpFile = null;
            try {
                if (proxy.doGet(url) != 200) {
                    throw new IOException("404");
                }
                tmpFile = File.createTempFile("packmgr", ".zip");
                FileOutputStream os = FileUtils.openOutputStream((File)tmpFile);
                try {
                    proxy.spool(os);
                }
                finally {
                    IOUtils.closeQuietly((OutputStream)os);
                }
            }
            finally {
                proxy.close();
            }
            tracker.message("adding", "");
            response.log("adding package to repository...", new Object[0]);
            pack = this.pkgMgr.upload(tmpFile, true, true, "unknown", true);
            tracker.message("downloaded", "");
            response.success("Package downloaded.", "Package <strong>" + (Object)pack.getDefinition().getId() + "</strong> downloaded successfully.");
        }
        catch (Exception e) {
            if (tracker != null) {
                tracker.message("error", e.toString());
            }
            throw e;
        }
        finally {
            if (pack != null) {
                pack.close();
            }
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private void createPackage(Response response) throws PackageException, RepositoryException, IOException {
        block7 : {
            RequestWrapper req = response.getServletRequest();
            JcrPackage pack = null;
            try {
                response.start("Creating package");
                String packageName = req.getParameter("packageName");
                if (packageName == null) {
                    throw new IllegalArgumentException("packageName parameter missing");
                }
                response.log("Name: %s", packageName);
                String groupName = req.getParameter("groupName");
                if (groupName == null) {
                    throw new IllegalArgumentException("groupName parameter missing");
                }
                response.log("Group: %s", groupName);
                String version = req.getParameter("packageVersion");
                response.log("Version: %s", version);
                pack = this.pkgMgr.create(groupName, packageName, version);
                if (pack == null) {
                    response.error("Unable to create package.");
                    break block7;
                }
                response.setPath(pack.getNode().getPath());
                response.success("Package created", "Package <strong>" + (Object)pack.getDefinition().getId() + "</strong> created successfully.");
            }
            finally {
                if (pack != null) {
                    pack.close();
                }
            }
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private void uploadPackage(Response response) throws IOException, PackageException, RepositoryException {
        block15 : {
            RequestWrapper req = response.getServletRequest();
            JcrPackage pack = null;
            try {
                int idx;
                response.start("Uploading package");
                File file = req.getFileParameter("package");
                if (file == null) {
                    throw new IllegalArgumentException("package file parameter missing");
                }
                String fileName = req.getParameter("package");
                if (fileName == null) {
                    fileName = file.getName();
                }
                if ((idx = fileName.lastIndexOf(47)) < 0) {
                    idx = fileName.lastIndexOf(92);
                }
                if (idx >= 0) {
                    fileName = fileName.substring(idx + 1);
                }
                FileInputStream in = FileUtils.openInputStream((File)file);
                boolean force = "true".equals(req.getParameter("force"));
                FileOutputStream os = null;
                File tmpFile = null;
                try {
                    tmpFile = File.createTempFile("vaultpack", ".zip");
                    os = FileUtils.openOutputStream((File)tmpFile);
                    IOUtils.copy((InputStream)in, (OutputStream)os);
                }
                catch (Exception e) {
                    if (tmpFile != null) {
                        tmpFile.delete();
                    }
                    throw new PackageException("Error while creating tmp file.", (Throwable)e);
                }
                finally {
                    IOUtils.closeQuietly((InputStream)in);
                    IOUtils.closeQuietly((OutputStream)os);
                }
                pack = this.pkgMgr.upload(tmpFile, true, force, fileName, true);
                if (pack == null) {
                    response.error("Unable to upload package. No Package");
                    break block15;
                }
                response.setPath(pack.getNode().getPath());
                response.success("Package uploaded", "Package <strong>" + (Object)pack.getDefinition().getId() + "</strong> created successfully.");
            }
            finally {
                if (pack != null) {
                    pack.close();
                }
            }
        }
    }

    private void deletePackage(JcrPackageManager packMgr, JcrPackage pack, Response response) throws IOException, RepositoryException {
        response.start("Deleting package");
        packMgr.remove(pack);
        response.success("Package deleted");
    }

    private void replicatePackage(JcrPackageManager packMgr, JcrPackage pack, Response response) throws IOException, RepositoryException, ReplicationException {
        response.start("Replicating package");
        Node node = pack.getNode();
        this.replicator.replicate(node.getSession(), ReplicationActionType.ACTIVATE, node.getPath());
        response.success("Package is replicated asynchronously");
    }

    private void stampThumbnail(Node defNode, Response response) {
        try {
            ImageResource image = new ImageResource(defNode, "thumbnail");
            image.setItemName("file", "file");
            image.setItemName("imageRotate", "rotate");
            image.setItemName("imageCrop", "crop");
            image.setItemName("fileReference", "reference");
            if (!image.hasContent()) {
                return;
            }
            response.log("Embedding thumbnail...", new Object[0]);
            Layer layer = GfxHelper.stampThumbnail(image);
            ImageHelper.saveLayer(layer, "image/png", 1.0, defNode, "thumbnail.png", false);
        }
        catch (Exception e) {
            log.error("Error while stamping layer", (Throwable)e);
        }
    }

    private void stampScreenshots(Node defNode, Response response) {
        try {
            if (!defNode.hasNode("screenshots")) {
                return;
            }
            NodeIterator iter = defNode.getNode("screenshots").getNodes();
            while (iter.hasNext()) {
                this.stampScreenshot(iter.nextNode(), response);
            }
        }
        catch (RepositoryException e) {
            log.error("Error while processing screenshot layer", (Throwable)e);
        }
    }

    private void stampScreenshot(Node node, Response response) {
        try {
            ImageResource image = new ImageResource(node);
            if (!image.hasContent()) {
                return;
            }
            response.log("Embedding %s...", Text.getName((String)node.getPath()));
            Layer layer = GfxHelper.stampScreenshot(image, true);
            if (layer != null) {
                String mimeType = image.getMimeType();
                if (ImageHelper.getExtensionFromType(mimeType) == null) {
                    mimeType = "image/png";
                }
                ImageHelper.saveLayer(layer, mimeType, 1.0, node, "file", true);
                this.removeProperty(node, "imageCrop");
                this.removeProperty(node, "imageRotate");
                this.removeProperty(node, "width");
                this.removeProperty(node, "height");
                node.save();
            }
        }
        catch (Exception e) {
            log.error("Error while creating screenshost", (Throwable)e);
        }
    }

    private void removeProperty(Node node, String name) {
        try {
            if (node.hasProperty(name)) {
                node.getProperty(name).remove();
            }
        }
        catch (RepositoryException e) {
            // empty catch block
        }
    }

    static class 1 {
        static final /* synthetic */ int[] $SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD;

        static {
            $SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD = new int[CMD.values().length];
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.create.ordinal()] = 1;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.upload.ordinal()] = 2;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.build.ordinal()] = 3;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.contents.ordinal()] = 4;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.dryrun.ordinal()] = 5;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.install.ordinal()] = 6;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.preview.ordinal()] = 7;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.rewrap.ordinal()] = 8;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.share.ordinal()] = 9;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.uninstall.ordinal()] = 10;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.delete.ordinal()] = 11;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.replicate.ordinal()] = 12;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.shareUpload.ordinal()] = 13;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.shareDownload.ordinal()] = 14;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
            try {
                1.$SwitchMap$com$day$crx$packaging$impl$J2EEPackageManager$CMD[CMD.validateDownload.ordinal()] = 15;
            }
            catch (NoSuchFieldError ex) {
                // empty catch block
            }
        }
    }

    private static enum CMD {
        upload,
        create,
        delete,
        dryrun,
        preview,
        contents,
        build,
        rewrap,
        install,
        uninstall,
        replicate,
        share,
        shareUpload,
        shareDownload,
        validateDownload,
        nop;
        

        private CMD() {
        }
    }

}