Meta Data Store (MDS)

Meta Data Store:

The MDS is basically an XML store with transaction capabilities, versioning, merging and a persistence framework optimized to work with XML nodes and attributes.  The persistence framework has two adapters that can persist the store to a database or to a folder on disk. The database store has more advanced features is the recommended way of working with MDS. The file store is useful for at development time, because one can change the files manually.

SOA 11g and 12c provides us with MDS repository (both file based & DB based) where common artifacts can be stored and referenced by all projects in the SOA infrastructure.

File and DB Based MDS:
File based MDS is used during design/deploy time whereas DB based MDS is used at run-time by the SOA infra. A configuration file named adf-config.xml that is part of every SOA project manages this partition mapping to be used by JDeveloper during design/deploy time.

File Based MDS:

The idea behind file-based repositories is to allow developers to have a light repository available in their local environment that can be easily adapted for development and tests; a file-based repository relieves developers of having to configure and maintain an external database while providing necessary functionality, such as file referencing and customizations. These kinds of repositories are easily modified and maintained, since they define a directory structure similar to any other directory structure inside an operating system. They can be navigated and altered using common shell commands or any kind of visual file explorer application. The file-based repository is usually located inside the Oracle JDeveloper home (JDEV_HOME/integration) if the default configuration is used.

MDS is created under <JDEV_HOME>/integration/seed directory. Default folder “soa” is used to store common system soa artifacts. All custom artifacts are supposed to be stored under a folder called “apps”, since this folder already exists in server.

Create directory structure under apps folder. In my case, I’ve created folder structure <JDEV_HOME>/integration/seed/apps/<myproject>/common/xsd to store XML schema files. This ideally should match your schema structure.

 

·         First you go to your local 12c Jdeveloper installation folder. In my case it is  C:\1221\Oracle\Middleware\Oracle_Home\jdeveloper\integration\seed folder .You can see seed folder, If not create a seed folder.

·         Now create folder with name apps under seed.

·         Under apps you can create your folder structure to place all your XSD, WSDL files like apps/xsd/<*.xsd> etc.

·         Create MDS connection in Jdeveloper as below

                I. We can find Resource palette pane on left side of the Jdeveloper

                II. Click on New SOA-MDS Connection for creation of new SOA-MDS connection like below

In Create SOA-MDS Connection window, select File Based MDS as Connection Type for file based MDS connection. We will point to the local folder in our system where all the WSDL and XSD files are placed as shown below. So when we use the wsdl and xsd files in the project, they will be referred from the local system. Click on Test Connection, It will show the status as ‘Success’.

Click OK. Now the File Based MDS connection is created. Now we can see the MDS connection tree structure on left pane under SOA-MDS.

Once the artifacts that needs to be shared/referenced are placed under the appropriate namespace (in this case 'apps'), we can let the SOA project in JDeveloper to point to MDS for these artifacts from a common location.

adf-config.xml configuration:

As noted earlier, adf-config.xml is an important configuration file which holds the details regarding the MDS (both file based & DB based). By default, this file declares the 'seed' partition & the metadata store for 'soa' namespace.

This file can be found under <YourApplication>\.adf\META-INF.
Alternatively, in JDeveloper, expand the 'Application Resources' panel; drill through Descriptors -> ADF META-INF to find this file

Step 1: Just add the metadata store namespace for '/apps' in additions to default '/soa/shared' namespace - This is to let the JDeveloper reference the artifacts under the '/apps' during the design time from the file system metadata store.

Adf-config.xml:

Step 2: In the SOA composite.xml, reference the common artifacts from MDS as shown below;

 <import namespace="http://xmlns.oracle.com/bpmn/bpmnProcess/CommenErrorHandlerProcess"

          location="oramds:/apps/Tesco/common/CommenErrorHandlerProcess.wsdl"

          importType="wsdl"/>

There are two methods available for us to deploy the artifacts in SOA File/DB based MDS.

Approach 1: Ant based script which allows to deploy the artifacts into SOA MDS. I am not going to get to the details of this as this has been blogged in detail by Edwin Biemond.

Reference below:

http://biemond.blogspot.com/2009/11/soa-suite-11g-mds-deploy-and-removal.html

Note: The same process is applicable for 12c too.

Approach 2: For a simple Manual Process SOA MDS deployment follow the steps below.

• Open EM console. And click on soa-infra (soa_server (In my case Admin Server)) under SOA on left pane of EM console.

•  Click on Administration---> MDS Configuration

•   In the Import section choose the ZIP file which is having your MDS files.

• Click on Import.

•   It will import the MDS to server.

• Click on Close button. This will complete our SOA-MDS Deployment.

DB Based MDS:

Database-based repositories are used in production environments where robustness is needed. These repositories are created using the Repository Creation Utility (RCU) application from Oracle. This utility helps with the creation of a new database schema with its corresponding tables and objects. Repositories can later be registered or deregistered via the Oracle Enterprise Manager Fusion Middleware Control console.

Let’s see how to create DB based MDS connection. In Create SOA_MDS Connection window, select  DB Based MDS as Connection Type for file based MDS connection.

For DB Based MDS connection, we should have created the entire schema for the weblogic in the database by running the Repository Creation Utility (RCU) wizard. After RCU execution, the DEV_MDS schema will get created in the database. We need to use the DEV_MDS schema connection and soa-infra as MDS Partition while creating the DB Based MDS connection as shown in the below screen shot.

Click OK. Now the DB Based MDS connection is created.

adf-config.xml configuration:

Modify adf-config.xml with desired information.

 adf-config.xml:

Working with Oracle MDS Repository (MetaData Services)

With the release of FMW 11g, the Oracle MDS Repository is now the central place for storing configuration files, personalization elements, page customizations, pages etc. for WebCenter, IDM and SOA Suite. Understanding and working with this repository is essential for custom application developers and implementers.

Oracle provides some basic tools for managing the repository, such as import/export and a JDeveloper browser plugin. Unfortunately, there is no tool currently for managing the files within the repository, so there really is no possibility to change the files at run-time without exporting and then reimporting the repository.

I will explain in this blog post how you can connect to a MDS repository and how you can work with the files stored there.

The MDS is basically an XML store with transaction capabilities, versioning, merging and a persistence framework optimized to work with XML nodes and attributes. It is somehow similar to an ORM, but for XML entities. The persistence framework has two adapters that can persist the store to a database or to a folder on disk. The database store has more advanced features is the recommended way of working with MDS. The file store is useful for at development time, because one can change the files manually.

The same as an ORM needs a configuration file to know the environment (e.g. hibernate.cfg.xml), the MDS uses its own config file named adf-config.xml. You can find this file automatically generated by JDeveloper in any SOA FMW project, with a default configuration.

The file has several configuration sections, but one is of particular interest, and it's called
adf-mds-config:

<adf-mds-config>

  <mds-config>

    <type-config>

      <type-definitions>

        <classpath>/com/tutorial/model/schema/beanType.xsd</classpath>

        ......

      </type-definitions>

    </type-config>

  </mds-config>

  <persistence-config>

    <metadata-namespaces>

      <namespace metadata-store-usage="MetadataStore" path="/custom/" />

      ......

    </metadata-namespaces>

    <metadata-store-usages>

      <metadata-store-usage default-cust-store="true" deploy-target="true" id="MetadataStore">

         <metadata-store class-name="oracle.mds.persistence.stores.db.DBMetadataStore">

           <property name="jdbc-userid" value="DEV_MDS"/>

           <property name="jdbc-password" value="dev"/>

           <property name="jdbc-url" value="jdbc:oracle:thin:@localhost:1521:orcl"/>

           <property name="partition-name" value="p1"/>

           <property name="repository-name" value="mds-SpacesDS"/>

         </metadata-store>

      </metadata-store-usage>

    </metadata-store-usages>

  </persistence-config>

</adf-mds-config>

In the above configuration, the most interesting elements are: type-definitions, namespace andmetadata-store:

·                      type-definitions: here you can define custom XSD nodes that describe custom entities. The easiest way to generate XSD definitions is with the help of JAXB: you can define you data model as serializable POJOs  (same as JPA entities) and then use Oracle's MDSBeanGenTool (located in the mdstools.jar file) java utility to generate the schema definition.

·                      namespace: here you must define the virtual paths within the MDS repository, so the persistence framework will know where to store and find the files

·                      metadata-store: this node configures the persistence adaper. It can be either DBMetadataStore, ClassPathMetadataStore, FileMetadataStore or ServletContextMetadataStore.

Once you have these in place, you are ready to connect to the metadata store:

MDSConfig config = new MDSConfig(new File(path to adf-config.xml));
MDSInstance mdsInstance = MDSInstance.getOrCreateInstance("test-instance", config);
MDSSession mdsSession = mdsInstance.createSession(new SessionOptions(null, null, new CustConfig(new CustClassListMapping[0])), null);

The mdsSession variable holds the session instance for the MDS repository. A MDSSession is similar to the Hibernate Session object. It will handle all persistence operations and holds a transactional context.
You can now query the repository to find the desired items. For example, to find all files in repository you would write:

NameQueryImpl query = new NameQueryImpl(mdsSession, ConditionFactory.createNameCondition("/", "%", true));
Iterator<QueryResult> result = query.execute();
while(result.hasNext()) {
    QueryResult qr = result.next();
    // ...do your magic here...
}

Using the above query, you would only retrieve the names of the items inside the repository. To get the actual instance of an MDS object ( MetadataObject ), you have to write:

MOReference ref = mdsSession.getMOReference(path inside the repository);
MetadataObject mo = mdsSession.getMetadataObject(ref);

Once you have the MetadataObject instance, you can retrieve the XML document behind withmo.getDocument(); Having the DOM XML Document instance, you can alter the XML file and save it hack to the repository by issuing mdsSession.flushChanges();

Using the information briefly described here and with a little bit of SWING knowledge, you can easily write an MDS browser and XML editor to change what you want inside the repository.