path: root/plugins/org.eclipse.emf.cdo.server/src/org/eclipse/emf/cdo/internal/server/bundle/CDOCommandProvider.java

/*
 * Copyright (c) 2010-2013, 2016, 2018 Eike Stepper (Loehne, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Eike Stepper - initial API and implementation
 *    Christian W. Damus (CEA LIST) - bug 420540
 */
package org.eclipse.emf.cdo.internal.server.bundle;

import org.eclipse.emf.cdo.common.lock.IDurableLockingManager;
import org.eclipse.emf.cdo.common.util.CDOCommonUtil;
import org.eclipse.emf.cdo.server.CDOServerExporter;
import org.eclipse.emf.cdo.server.CDOServerImporter;
import org.eclipse.emf.cdo.server.CDOServerUtil;
import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.server.IStoreAccessor;
import org.eclipse.emf.cdo.spi.common.branch.InternalCDOBranch;
import org.eclipse.emf.cdo.spi.common.model.InternalCDOPackageInfo;
import org.eclipse.emf.cdo.spi.common.model.InternalCDOPackageRegistry;
import org.eclipse.emf.cdo.spi.common.model.InternalCDOPackageUnit;
import org.eclipse.emf.cdo.spi.server.CDOCommand;
import org.eclipse.emf.cdo.spi.server.CDOCommand.CommandException;
import org.eclipse.emf.cdo.spi.server.InternalRepository;
import org.eclipse.emf.cdo.spi.server.InternalSession;
import org.eclipse.emf.cdo.spi.server.InternalSessionManager;
import org.eclipse.emf.cdo.spi.server.InternalView;
import org.eclipse.emf.cdo.spi.server.RepositoryConfigurator;
import org.eclipse.emf.cdo.spi.server.RepositoryFactory;

import org.eclipse.net4j.util.container.IManagedContainer;
import org.eclipse.net4j.util.container.IPluginContainer;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.lifecycle.LifecycleUtil;

import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;

import org.osgi.framework.BundleContext;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author Eike Stepper
 */
public class CDOCommandProvider implements CommandProvider
{
  private static final String NEW_LINE = "\r\n"; //$NON-NLS-1$

  private static final CDOCommand list = new CDOCommand("list", "list all active repositories")
  {
    @Override
    public void execute(String[] args) throws Exception
    {
      IManagedContainer container = CDOServerApplication.getContainer();
      for (Object element : container.getElements(RepositoryFactory.PRODUCT_GROUP))
      {
        if (element instanceof InternalRepository)
        {
          InternalRepository repository = (InternalRepository)element;
          println(repository.getName());
        }
      }
    }
  };

  private static final CDOCommand start = new CDOCommand("start", "start repositories from a config file", CDOCommand.parameter("config-file"))
  {
    @Override
    public void execute(String[] args) throws Exception
    {
      String configFile = args[0];

      IManagedContainer container = CDOServerApplication.getContainer();
      RepositoryConfigurator repositoryConfigurator = new RepositoryConfigurator(container);
      IRepository[] repositories = repositoryConfigurator.configure(new File(configFile));

      println("Repositories started:");
      if (repositories != null)
      {
        for (IRepository repository : repositories)
        {
          println(repository.getName());
        }
      }
    }
  };

  private static final CDOCommand stop = new CDOCommand.WithRepository("stop", "stop a repository")
  {
    @Override
    public void execute(InternalRepository repository, String[] args) throws Exception
    {
      LifecycleUtil.deactivate(repository);
      println("Repository stopped");
    }
  };

  private static final CDOCommand exportXML = new CDOCommand.WithRepository("export", "export the contents of a repository to an XML file",
      CDOCommand.parameter("export-file"))
  {
    @Override
    public void execute(InternalRepository repository, String[] args) throws Exception
    {
      String exportFile = args[0];
      OutputStream out = null;

      try
      {
        out = new FileOutputStream(exportFile);

        CDOServerExporter.XML exporter = new CDOServerExporter.XML(repository);
        exporter.exportRepository(out);

        if (args.length > 1)
        {
          if ("withSystemPackages".equalsIgnoreCase(args[1]))
          {
            exporter.setExportSystemPackages(true);
          }
        }

        println("Repository exported");
      }
      finally
      {
        IOUtil.close(out);
      }
    }
  };

  private static final CDOCommand importXML = new CDOCommand.WithRepository("import", "import the contents of a repository from an XML file",
      CDOCommand.parameter("import-file"))
  {
    @Override
    public void execute(InternalRepository repository, String[] args) throws Exception
    {
      String importFile = args[0];
      InputStream in = null;

      try
      {
        in = new FileInputStream(importFile);
        LifecycleUtil.deactivate(repository);

        CDOServerImporter.XML importer = new CDOServerImporter.XML(repository);
        importer.importRepository(in);

        IManagedContainer container = CDOServerApplication.getContainer();
        CDOServerUtil.addRepository(container, repository);

        println("Repository imported");
      }
      finally
      {
        IOUtil.close(in);
      }
    }
  };

  private static final CDOCommand branches = new CDOCommand.WithRepository("branches", "dump the branches of a repository")
  {
    @Override
    public void execute(InternalRepository repository, String[] args) throws Exception
    {
      branches(repository.getBranchManager().getMainBranch(), "");
    }

    private void branches(InternalCDOBranch branch, String prefix)
    {
      println(prefix + branch);
      prefix += CDOCommand.INDENT;
      for (InternalCDOBranch child : branch.getBranches())
      {
        branches(child, prefix);
      }
    }
  };

  private static final CDOCommand packages = new CDOCommand.WithRepository("packages", "dump the packages of a repository")
  {
    @Override
    public void execute(InternalRepository repository, String[] args) throws Exception
    {
      InternalCDOPackageRegistry packageRegistry = repository.getPackageRegistry(false);
      for (InternalCDOPackageUnit packageUnit : packageRegistry.getPackageUnits())
      {
        println(packageUnit);
        for (InternalCDOPackageInfo packageInfo : packageUnit.getPackageInfos())
        {
          println(CDOCommand.INDENT + packageInfo);
        }
      }
    }
  };

  private static final CDOCommand sessions = new CDOCommand.WithRepository("sessions", "dump the sessions of a repository")
  {
    @Override
    public void execute(InternalRepository repository, String[] args) throws Exception
    {
      InternalSessionManager sessionManager = repository.getSessionManager();
      for (InternalSession session : sessionManager.getSessions())
      {
        println(session);
        for (InternalView view : session.getViews())
        {
          println(INDENT + view);
        }
      }
    }
  };

  private static final CDOCommand locks = new CDOCommand.WithAccessor("locks", "dump the locks of a repository", CDOCommand.optional("username-prefix"))
  {
    @Override
    public void execute(InternalRepository repository, IStoreAccessor accessor, String[] args) throws Exception
    {
      String usernamePrefix = args[0];

      repository.getLockingManager().getLockAreas(usernamePrefix, new IDurableLockingManager.LockArea.Handler()
      {
        public boolean handleLockArea(IDurableLockingManager.LockArea area)
        {
          println(area.getDurableLockingID());
          println(CDOCommand.INDENT + "userID = " + area.getUserID());
          println(CDOCommand.INDENT + "branch = " + area.getBranch());
          println(CDOCommand.INDENT + "timeStamp = " + CDOCommonUtil.formatTimeStamp(area.getTimeStamp()));
          println(CDOCommand.INDENT + "readOnly = " + area.isReadOnly());
          println(CDOCommand.INDENT + "locks = " + area.getLocks());
          return true;
        }
      });
    }
  };

  private static final CDOCommand deletelocks = new CDOCommand.WithAccessor("deletelocks", "delete a durable locking area of a repository",
      CDOCommand.parameter("area-id"))
  {
    @Override
    public void execute(InternalRepository repository, IStoreAccessor accessor, String[] args) throws Exception
    {
      String areaID = args[0];
      repository.getLockingManager().deleteLockArea(areaID);
    }
  };

  public CDOCommandProvider(BundleContext bundleContext)
  {
    bundleContext.registerService(CommandProvider.class.getName(), this, null);
  }

  public Object _cdo(CommandInterpreter interpreter)
  {
    try
    {
      Map<String, CDOCommand> commands = getCommands();
      String cmd = interpreter.nextArgument();

      CDOCommand command = commands.get(cmd);
      if (command != null)
      {
        try
        {
          command.setInterpreter(interpreter);
          command.execute();
          return null;
        }
        finally
        {
          command.setInterpreter(null);
        }
      }

      interpreter.println(getHelp());
    }
    catch (CommandException ex)
    {
      interpreter.println(ex.getMessage());
    }
    catch (Exception ex)
    {
      interpreter.printStackTrace(ex);
    }

    return null;
  }

  public String getHelp()
  {
    StringBuilder builder = new StringBuilder();

    try
    {
      builder.append("---CDO commands---" + NEW_LINE);

      List<CDOCommand> commands = new ArrayList<CDOCommand>(getCommands().values());
      Collections.sort(commands, new Comparator<CDOCommand>()
      {
        public int compare(CDOCommand o1, CDOCommand o2)
        {
          return o1.getName().compareTo(o2.getName());
        }
      });

      for (CDOCommand command : commands)
      {
        try
        {
          builder.append(CDOCommand.INDENT);
          builder.append(command.getSyntax());
          builder.append(" - ");
          builder.append(command.getDescription());
          builder.append(NEW_LINE);
        }
        catch (Exception ex)
        {
          OM.LOG.error(ex);
        }
      }
    }
    catch (Exception ex)
    {
      OM.LOG.error(ex);
    }

    return builder.toString();
  }

  public synchronized Map<String, CDOCommand> getCommands()
  {
    Map<String, CDOCommand> commands = new HashMap<String, CDOCommand>();
    addCommand(commands, list);
    addCommand(commands, start);
    addCommand(commands, stop);
    addCommand(commands, exportXML);
    addCommand(commands, importXML);
    addCommand(commands, branches);
    addCommand(commands, deletelocks);
    addCommand(commands, locks);
    addCommand(commands, packages);
    addCommand(commands, sessions);

    try
    {
      for (String name : IPluginContainer.INSTANCE.getFactoryTypes(CDOCommand.PRODUCT_GROUP))
      {
        try
        {
          CDOCommand command = createCommand(name);
          addCommand(commands, command);
        }
        catch (Exception ex)
        {
          OM.LOG.error(ex);
        }
      }
    }
    catch (Exception ex)
    {
      OM.LOG.error(ex);
    }

    return commands;
  }

  protected CDOCommand createCommand(String name)
  {
    return (CDOCommand)IPluginContainer.INSTANCE.getElement(CDOCommand.PRODUCT_GROUP, name, null);
  }

  private void addCommand(Map<String, CDOCommand> commands, CDOCommand command)
  {
    commands.put(command.getName(), command);
  }
}