package com.atlassian.plugin.main;
   
   import java.io.File;
   import java.io.IOException;
   import java.io.InputStream;
   import java.util.Collections;
   import java.util.Properties;
   import java.util.concurrent.TimeUnit;
   
  import com.atlassian.plugin.osgi.container.PackageScannerConfiguration;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.log4j.Logger;
  import org.apache.log4j.PropertyConfigurator;
  
  import static com.atlassian.plugin.main.PackageScannerConfigurationBuilder.packageScannerConfiguration;
  import static com.atlassian.plugin.main.PluginsConfigurationBuilder.pluginsConfiguration;
  
  /**
   * Simple standalone class for starting the plugin framework.  Creates a directory called "plugins" in the current directory
   * and scans it every 5 seconds for new plugins.
   * <p/>
   * For embedded use, use the {@link AtlassianPlugins} facade directly
   */
  public class Main
  {
      public static void main(final String[] args)
      {
          initialiseLogger();
          final File pluginDir = new File("plugins");
  
          if (pluginDir.mkdir())
          {
              System.out.println("Created plugins directory " + pluginDir.getAbsolutePath());
          }
          else if (pluginDir.isDirectory())
          {
              System.out.println("Using existing plugins directory " + pluginDir.getAbsolutePath());
          }
          else
          {
              System.out.println("Cannot create plugins directory " + pluginDir.getAbsolutePath());
          }
  
          final PackageScannerConfiguration packageScannerConfiguration = packageScannerConfiguration()
                  .packagesToInclude("org.apache.*", "com.atlassian.*", "org.dom4j*")
                  .packagesVersions(Collections.singletonMap("org.apache.log4j", "1.2.15"))
                  .build();
          final PluginsConfiguration config = pluginsConfiguration()
                  .pluginDirectory(pluginDir)
                  .packageScannerConfiguration(packageScannerConfiguration)
                  .hotDeployPollingFrequency(5, TimeUnit.SECONDS)
                  .build();
          final AtlassianPlugins plugins = new AtlassianPlugins(config);
  
          Runtime.getRuntime().addShutdownHook(new Thread()
          {
              @Override
              public void run()
              {
                  System.out.println("Cleaning up...");
                  plugins.stop();
              }
          });
  
          plugins.start();
  
          // Keep the vm alive - kill it with a SIGHUP to test shutdown
          try
          {
              final Object waitable = new Object();
              // We're synchronizing just so we can wait() to block the thread, so the fact it's a local is moot.
              //noinspection SynchronizationOnLocalVariableOrMethodParameter
              synchronized (waitable)
              {
                  waitable.wait();
              }
          }
          catch (final InterruptedException e)
          {
              // ignore, but now the wait is over
          }
      }
  
      private static void initialiseLogger()
      {
          final Properties logProperties = new Properties();
  
          InputStream in = null;
          try
          {
              in = Main.class.getResourceAsStream("/log4j-standalone.properties");
              logProperties.load(in);
              PropertyConfigurator.configure(logProperties);
              Logger.getLogger(Main.class).info("Logging initialized.");
          }
          catch (final IOException e)
          {
              throw new RuntimeException("Unable to load logging");
         }
         finally
         {
             IOUtils.closeQuietly(in);
         }
     }
 }