/**
  * Find PersistenceUnitInfo corresponding to the persistence unit name. Returns null if either
  * persistence unit either not found or provider is not supported.
  */
 protected SEPersistenceUnitInfo findPersistenceUnitInfoInArchives(String puName, Map m) {
   SEPersistenceUnitInfo persistenceUnitInfo = null;
   // mkeith - get resource name from prop and include in subsequent call
   String descriptorPath = (String) m.get(PersistenceUnitProperties.ECLIPSELINK_PERSISTENCE_XML);
   final Set<Archive> pars;
   if (descriptorPath != null) {
     pars =
         PersistenceUnitProcessor.findPersistenceArchives(
             initializationClassloader, descriptorPath);
   } else {
     pars = PersistenceUnitProcessor.findPersistenceArchives(initializationClassloader);
   }
   try {
     for (Archive archive : pars) {
       persistenceUnitInfo = findPersistenceUnitInfoInArchive(puName, archive, m);
       if (persistenceUnitInfo != null) {
         break;
       }
     }
   } finally {
     for (Archive archive : pars) {
       archive.close();
     }
   }
   return persistenceUnitInfo;
 }
 /**
  * This method initializes the container. Essentially, it will try to load the class that contains
  * the list of entities and reflectively call the method that contains that list. It will then
  * initialize the container with that list.
  */
 public void initialize(Map m) {
   boolean keepInitialMaps = keepAllPredeployedPersistenceUnits();
   if (keepInitialMaps) {
     this.initialPuInfos = new HashMap();
   }
   // always create initialEmSetupImpls - it's used to check for puName uniqueness in
   // initPersistenceUnits
   this.initialEmSetupImpls = new HashMap();
   // ailitchev - copied from findPersistenceUnitInfoInArchives: mkeith - get resource name from
   // prop and include in subsequent call
   String descriptorPath = (String) m.get(PersistenceUnitProperties.ECLIPSELINK_PERSISTENCE_XML);
   final Set<Archive> pars;
   if (descriptorPath != null) {
     pars =
         PersistenceUnitProcessor.findPersistenceArchives(
             initializationClassloader, descriptorPath);
   } else {
     pars = PersistenceUnitProcessor.findPersistenceArchives(initializationClassloader);
   }
   try {
     for (Archive archive : pars) {
       AbstractSessionLog.getLog().log(SessionLog.FINER, "cmp_init_initialize", archive);
       initPersistenceUnits(archive, m);
     }
   } finally {
     for (Archive archive : pars) {
       archive.close();
     }
     this.initialEmSetupImpls = null;
   }
 }
  /**
   * Return a list of Archives representing the root of the persistence descriptor. It is the
   * caller's responsibility to close all the archives.
   *
   * @param loader the class loader to get the class path from
   */
  public static Set<Archive> findPersistenceArchives(ClassLoader loader, String descriptorPath) {
    Archive archive = null;

    Set<Archive> archives = new HashSet<Archive>();

    // See if we are talking about an embedded descriptor
    int splitPosition = descriptorPath.indexOf("!/");

    try {
      // If not embedded descriptor then just use the regular descriptor path
      if (splitPosition == -1) {
        Enumeration<URL> resources = loader.getResources(descriptorPath);
        while (resources.hasMoreElements()) {

          URL descUrl = resources.nextElement();
          if (descUrl != null) {
            URL puRootUrl = computePURootURL(descUrl, descriptorPath);
            archive =
                PersistenceUnitProcessor.getArchiveFactory(loader)
                    .createArchive(puRootUrl, descriptorPath, null);

            // archive = new BundleArchive(puRootUrl, descUrl);
            if (archive != null) {
              archives.add(archive);
            }
          }
        }
      } else {
        // It is an embedded archive, so split up the parts
        String jarPrefixPath = descriptorPath.substring(0, splitPosition);
        String descPath = descriptorPath.substring(splitPosition + 2);
        // TODO This causes the bundle to be resolved (not what we want)!
        URL prefixUrl = loader.getResource(jarPrefixPath);
        archive =
            PersistenceUnitProcessor.getArchiveFactory(loader)
                .createArchive(prefixUrl, descPath, null);

        if (archive != null) {
          archives.add(archive);
        }
      }
    } catch (Exception ex) {
      // clean up first
      for (Archive a : archives) {
        a.close();
      }
      throw PersistenceUnitLoadingException.exceptionSearchingForPersistenceResources(loader, ex);
    }
    return archives;
  }
  public static Set<String> getClassNamesFromURL(URL url, ClassLoader loader, Map properties) {
    Set<String> classNames = new HashSet<String>();
    Archive archive = null;
    try {
      archive = PersistenceUnitProcessor.getArchiveFactory(loader).createArchive(url, properties);

      if (archive != null) {
        for (Iterator<String> entries = archive.getEntries(); entries.hasNext(); ) {
          String entry = entries.next();
          if (entry.endsWith(".class")) { // NOI18N
            classNames.add(buildClassNameFromEntryString(entry));
          }
        }
      }
    } catch (URISyntaxException e) {
      throw new RuntimeException("url = [" + url + "]", e); // NOI18N
    } catch (IOException e) {
      throw new RuntimeException("url = [" + url + "]", e); // NOI18N
    } finally {
      if (archive != null) {
        archive.close();
      }
    }
    return classNames;
  }
  /**
   * Return a list of Archives representing the root of the persistence descriptor. It is the
   * caller's responsibility to close all the archives.
   *
   * @param loader the class loader to get the class path from
   */
  public static Set<Archive> findPersistenceArchives(
      ClassLoader loader, String descriptorPath, List<URL> jarFileUrls) {
    Archive archive = null;

    Set<Archive> archives = new HashSet<Archive>();

    // See if we are talking about an embedded descriptor
    // If not embedded descriptor then just use the regular descriptor path
    int splitPosition = descriptorPath.indexOf("!/");
    if (splitPosition != -1) {
      // It is an embedded archive, so split up the parts
      descriptorPath = descriptorPath.substring(splitPosition + 2);
    }

    try {
      for (int i = 0; i < jarFileUrls.size(); i++) {
        URL puRootUrl = jarFileUrls.get(i);
        archive =
            PersistenceUnitProcessor.getArchiveFactory(loader)
                .createArchive(puRootUrl, descriptorPath, null);

        // archive = new BundleArchive(puRootUrl, descUrl);
        if (archive != null) {
          archives.add(archive);
        }
      }
    } catch (Exception ex) {
      // clean up first
      for (Archive a : archives) {
        a.close();
      }
      throw PersistenceUnitLoadingException.exceptionSearchingForPersistenceResources(loader, ex);
    }
    return archives;
  }
  /** This is our chance to initialize any EclipseLink specific stuff */
  public void initialize() {
    // Set the static so initializer instances can get stuff from it
    GeminiOSGiInitializer.setManager(mgr);

    // Set to our own archive factory
    PersistenceUnitProcessor.setArchiveFactory(new OSGiArchiveFactoryImpl());

    // If EL logging property was specified then open the log now?
    openEclipseLinkLogFileIfSpecified();
  }
 /**
  * Find PersistenceUnitInfo corresponding to the persistence unit name in the archive. Returns
  * null if either persistence unit either not found or provider is not supported.
  */
 protected SEPersistenceUnitInfo findPersistenceUnitInfoInArchive(
     String puName, Archive archive, Map m) {
   Iterator<SEPersistenceUnitInfo> persistenceUnits =
       PersistenceUnitProcessor.getPersistenceUnits(archive, initializationClassloader).iterator();
   while (persistenceUnits.hasNext()) {
     SEPersistenceUnitInfo persistenceUnitInfo = persistenceUnits.next();
     if (isPersistenceProviderSupported(persistenceUnitInfo.getPersistenceProviderClassName())
         && persistenceUnitInfo.getPersistenceUnitName().equals(puName)) {
       return persistenceUnitInfo;
     }
   }
   return null;
 }
  /**
   * Initialize all persistence units found on initializationClassLoader. Initialization is a two
   * phase process. First the predeploy process builds the metadata and creates any required
   * transformers. Second the deploy process creates an EclipseLink session based on that metadata.
   */
  protected void initPersistenceUnits(Archive archive, Map m) {
    Iterator<SEPersistenceUnitInfo> persistenceUnits =
        PersistenceUnitProcessor.getPersistenceUnits(archive, initializationClassloader).iterator();
    while (persistenceUnits.hasNext()) {
      SEPersistenceUnitInfo persistenceUnitInfo = persistenceUnits.next();
      if (isPersistenceProviderSupported(persistenceUnitInfo.getPersistenceProviderClassName())) {
        // puName uniquely defines the pu on a class loader
        String puName = persistenceUnitInfo.getPersistenceUnitName();

        // don't add puInfo that could not be used standalone (only as composite member).
        if (EntityManagerSetupImpl.mustBeCompositeMember(persistenceUnitInfo)) {
          continue;
        }

        // If puName is already in the map then there are two jars containing persistence units with
        // the same name.
        // Because both are loaded from the same classloader there is no way to distinguish between
        // them - throw exception.
        EntityManagerSetupImpl anotherEmSetupImpl = null;
        if (initialEmSetupImpls != null) {
          anotherEmSetupImpl = this.initialEmSetupImpls.get(puName);
        }
        if (anotherEmSetupImpl != null) {
          EntityManagerSetupImpl.throwPersistenceUnitNameAlreadyInUseException(
              puName, persistenceUnitInfo, anotherEmSetupImpl.getPersistenceUnitInfo());
        }

        // Note that session name is extracted only from puInfo, the passed properties ignored.
        String sessionName =
            EntityManagerSetupImpl.getOrBuildSessionName(
                Collections.emptyMap(), persistenceUnitInfo, puName);
        EntityManagerSetupImpl emSetupImpl =
            callPredeploy(persistenceUnitInfo, m, puName, sessionName);
        if (initialEmSetupImpls != null) {
          this.initialEmSetupImpls.put(puName, emSetupImpl);
        }
        if (initialPuInfos != null) {
          this.initialPuInfos.put(puName, persistenceUnitInfo);
        }
      }
    }
  }
  /**
   * predeploy (with deploy) is one of the two steps required in deployment of entities This method
   * will prepare to call predeploy, call it and finally register the transformer returned to be
   * used for weaving.
   */
  public EntityManagerSetupImpl callPredeploy(
      SEPersistenceUnitInfo persistenceUnitInfo,
      Map m,
      String persistenceUnitUniqueName,
      String sessionName) {
    AbstractSessionLog.getLog()
        .log(
            SessionLog.FINER,
            "cmp_init_invoke_predeploy",
            persistenceUnitInfo.getPersistenceUnitName());
    Map mergedProperties =
        EntityManagerFactoryProvider.mergeMaps(m, persistenceUnitInfo.getProperties());
    // Bug#4452468  When globalInstrumentation is null, there is no weaving
    checkWeaving(mergedProperties);

    Set tempLoaderSet = PersistenceUnitProcessor.buildClassSet(persistenceUnitInfo, m);
    // Create the temp loader that will not cache classes for entities in our persistence unit
    ClassLoader tempLoader = createTempLoader(tempLoaderSet);
    persistenceUnitInfo.setNewTempClassLoader(tempLoader);

    EntityManagerSetupImpl emSetupImpl =
        new EntityManagerSetupImpl(persistenceUnitUniqueName, sessionName);

    // A call to predeploy will partially build the session we will use
    final ClassTransformer transformer =
        emSetupImpl.predeploy(persistenceUnitInfo, mergedProperties);

    // After preDeploy it's impossible to weave again - so may substitute the temporary classloader
    // with the real one.
    // The temporary classloader could be garbage collected even if the puInfo is cached for the
    // future use by other emSetupImpls.
    persistenceUnitInfo.setNewTempClassLoader(persistenceUnitInfo.getClassLoader());

    registerTransformer(transformer, persistenceUnitInfo, m);
    return emSetupImpl;
  }
  @Override
  public void buildSessions() {
    XRDynamicClassLoader xrdecl = new XRDynamicClassLoader(parentClassLoader);
    DatasourceLogin login = new DatabaseLogin();
    login.setUserName(username);
    login.setPassword(password);
    ((DatabaseLogin) login).setConnectionString(url);
    ((DatabaseLogin) login).setDriverClassName(DATABASE_PLATFORM);
    Platform platform = builder.getDatabasePlatform();
    ConversionManager conversionManager = platform.getConversionManager();
    if (conversionManager != null) {
      conversionManager.setLoader(xrdecl);
    }
    login.setDatasourcePlatform(platform);
    ((DatabaseLogin) login).bindAllParameters();
    ((DatabaseLogin) login).setUsesStreamsForBinding(true);

    Project orProject = null;
    if (DBWS_OR_STREAM.size() != 0) {
      MetadataProcessor processor =
          new MetadataProcessor(
              new XRPersistenceUnitInfo(xrdecl),
              new DatabaseSessionImpl(login),
              xrdecl,
              false,
              true,
              false,
              false,
              false,
              null,
              null);
      processor.setMetadataSource(
          new JPAMetadataSource(xrdecl, new StringReader(DBWS_OR_STREAM.toString())));
      PersistenceUnitProcessor.processORMetadata(
          processor, true, PersistenceUnitProcessor.Mode.ALL);
      processor.addNamedQueries();
      orProject = processor.getProject().getProject();
    } else {
      orProject = new Project();
    }
    orProject.setName(builder.getProjectName().concat(OR_PRJ_SUFFIX));
    orProject.setDatasourceLogin(login);
    DatabaseSession databaseSession = orProject.createDatabaseSession();
    if ("off".equalsIgnoreCase(builder.getLogLevel())) {
      databaseSession.dontLogMessages();
    } else {
      databaseSession.setLogLevel(
          AbstractSessionLog.translateStringToLoggingLevel(builder.getLogLevel()));
    }
    xrService.setORSession(databaseSession);
    orProject.convertClassNamesToClasses(xrdecl);

    Project oxProject = null;
    Map<String, OXMMetadataSource> metadataMap = new HashMap<String, OXMMetadataSource>();
    StreamSource xml = new StreamSource(new StringReader(DBWS_OX_STREAM.toString()));
    try {
      JAXBContext jc = JAXBContext.newInstance(XmlBindingsModel.class);
      Unmarshaller unmarshaller = jc.createUnmarshaller();

      JAXBElement<XmlBindingsModel> jaxbElt = unmarshaller.unmarshal(xml, XmlBindingsModel.class);
      XmlBindingsModel model = jaxbElt.getValue();
      for (XmlBindings xmlBindings : model.getBindingsList()) {
        metadataMap.put(xmlBindings.getPackageName(), new OXMMetadataSource(xmlBindings));
      }
    } catch (JAXBException jaxbex) {
      jaxbex.printStackTrace();
    }

    Map<String, Map<String, OXMMetadataSource>> properties =
        new HashMap<String, Map<String, OXMMetadataSource>>();
    properties.put(JAXBContextProperties.OXM_METADATA_SOURCE, metadataMap);
    try {
      org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContext jCtx =
          org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContextFactory.createContextFromOXM(
              parentClassLoader, properties);
      oxProject = jCtx.getXMLContext().getSession(0).getProject();
    } catch (JAXBException e) {
      e.printStackTrace();
    }
    ((XMLLogin) oxProject.getDatasourceLogin()).setPlatformClassName(DOM_PLATFORM_CLASSNAME);
    ((XMLLogin) oxProject.getDatasourceLogin()).setEqualNamespaceResolvers(false);

    prepareDescriptors(oxProject, orProject, xrdecl);
    ProjectHelper.fixOROXAccessors(orProject, oxProject);
    xrService.setORSession(databaseSession);
    xrService.setXMLContext(new XMLContext(oxProject));
    xrService.setOXSession(xrService.getXMLContext().getSession(0));
  }
예제 #11
0
 /**
  * In case persistence unit is not uniquely defined by name this method is called to generate a
  * unique name.
  */
 public String createUniquePersistenceUnitName(PersistenceUnitInfo puInfo) {
   return PersistenceUnitProcessor.buildPersistenceUnitName(
       puInfo.getPersistenceUnitRootUrl(), puInfo.getPersistenceUnitName());
 }
  /** INTERNAL: The method performs weaving function */
  private void process() throws IOException, URISyntaxException {
    // Instantiate output handler.
    AbstractStaticWeaveOutputHandler swoh;
    if (isDirectory(this.target)) {
      swoh = new StaticWeaveDirectoryOutputHandler(this.source, this.target);
    } else {
      swoh =
          new StaticWeaveJAROutputHandler(
              new JarOutputStream(new FileOutputStream(new File(Helper.toURI(this.target)))));
    }

    // Instantiate classloader.
    this.classLoader =
        (this.classLoader == null)
            ? Thread.currentThread().getContextClassLoader()
            : this.classLoader;
    this.classLoader = new URLClassLoader(getURLs(), this.classLoader);

    // Instantiate the classtransformer, we check if the persistenceinfo URL has been specified.
    StaticWeaveClassTransformer classTransformer = null;
    if (persistenceInfo != null) {
      classTransformer =
          new StaticWeaveClassTransformer(
              persistenceInfo,
              persistenceXMLLocation,
              this.classLoader,
              this.logWriter,
              this.logLevel);
    } else {
      classTransformer =
          new StaticWeaveClassTransformer(
              source, persistenceXMLLocation, this.classLoader, this.logWriter, this.logLevel);
    }

    // Starting process.
    Archive sourceArchive = (new ArchiveFactoryImpl()).createArchive(source, null, null);
    if (sourceArchive != null) {
      try {
        Iterator entries = sourceArchive.getEntries();
        while (entries.hasNext()) {
          String entryName = (String) entries.next();
          InputStream entryInputStream = sourceArchive.getEntry(entryName);

          // Add a directory entry
          swoh.addDirEntry(getDirectoryFromEntryName(entryName));

          // Add a regular entry
          JarEntry newEntry = new JarEntry(entryName);

          // Ignore non-class files.
          if (!(entryName.endsWith(".class"))) {
            swoh.addEntry(entryInputStream, newEntry);
            continue;
          }

          String className = PersistenceUnitProcessor.buildClassNameFromEntryString(entryName);

          byte[] originalClassBytes = null;
          byte[] transferredClassBytes = null;
          try {
            Class thisClass = this.classLoader.loadClass(className);
            // If the class is not in the classpath, we simply copy the entry
            // to the target(no weaving).
            if (thisClass == null) {
              swoh.addEntry(entryInputStream, newEntry);
              continue;
            }

            // Try to read the loaded class bytes, the class bytes is required for
            // classtransformer to perform transfer. Simply copy entry to the target(no weaving)
            // if the class bytes can't be read.
            InputStream is = this.classLoader.getResourceAsStream(entryName);
            if (is != null) {
              ByteArrayOutputStream baos = null;
              try {
                baos = new ByteArrayOutputStream();
                byte[] bytes = new byte[NUMBER_OF_BYTES];
                int bytesRead = is.read(bytes, 0, NUMBER_OF_BYTES);
                while (bytesRead >= 0) {
                  baos.write(bytes, 0, bytesRead);
                  bytesRead = is.read(bytes, 0, NUMBER_OF_BYTES);
                }
                originalClassBytes = baos.toByteArray();
              } finally {
                baos.close();
              }
            } else {
              swoh.addEntry(entryInputStream, newEntry);
              continue;
            }

            // If everything is OK so far, we perform the weaving. we need three parameters in order
            // to
            // class to perform weaving for that class, the class name,the class object and class
            // bytes.
            transferredClassBytes =
                classTransformer.transform(
                    className.replace('.', '/'), thisClass, originalClassBytes);

            // If transferredClassBytes is null means the class dose not get woven.
            if (transferredClassBytes != null) {
              swoh.addEntry(newEntry, transferredClassBytes);
            } else {
              swoh.addEntry(entryInputStream, newEntry);
            }
          } catch (IllegalClassFormatException e) {
            AbstractSessionLog.getLog().logThrowable(AbstractSessionLog.WARNING, e);
            // Anything went wrong, we need log a warning message, copy the entry to the target and
            // process next entry.
            swoh.addEntry(entryInputStream, newEntry);
            continue;
          } catch (ClassNotFoundException e) {
            AbstractSessionLog.getLog().logThrowable(AbstractSessionLog.WARNING, e);
            swoh.addEntry(entryInputStream, newEntry);
            continue;
          } finally {
            // Need close the inputstream for current entry before processing next one.
            entryInputStream.close();
          }
        }
      } finally {
        sourceArchive.close();
        swoh.closeOutputStream();
      }
    }
  }