Added: 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/reference/thread-model.html
==============================================================================
--- 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/reference/thread-model.html
 (added)
+++ 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/reference/thread-model.html
 Tue Mar 10 21:03:25 2015
@@ -0,0 +1,176 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
"http://www.w3.org/TR/html4/loose.dtd";>
+<html>
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You under the Apache License, Version 2.0
+    (the "License"); you may not use this file except in compliance with
+    the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE- 2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+  <head>
+    <title>Apache Felix - Apache Felix Dependency Manager - Thread 
Model</title>
+    <link rel="icon" href="/res/favicon.ico">
+    <link rel="stylesheet" href="/res/site.css" type="text/css" media="all">
+    <link rel="stylesheet" href="/res/codehilite.css" type="text/css" 
media="all">
+    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+  </head>
+  <body>
+    <div class="title">
+      <div class="logo">
+        <a href="http://felix.apache.org/";>
+          <img border="0" alt="Apache Felix" src="/res/logo.png">
+        </a>
+      </div>
+      <div class="header">
+        <a href="http://www.apache.org/";>
+          <img border="0" alt="Apache" src="/res/apache.png">
+        </a>
+      </div>
+    </div>
+    
+    <div class="menu"> 
+      <p><a href="/news.html">news</a>  <br />
+<a href="/license.html">license</a>  <br />
+<a href="/downloads.cgi">downloads</a>  <br />
+<a href="/documentation.html">documentation</a>  <br />
+<a href="/mailinglists.html">mailing lists</a>  <br />
+<a href="/documentation/community/contributing.html">contributing</a>  <br />
+<a href="/sitemap.html">site map</a>  <br />
+<a href="http://www.apache.org/";>asf</a>  <br />
+<a href="http://www.apache.org/security/";>security</a>  <br />
+<a href="http://www.apache.org/foundation/sponsorship.html";>sponsorship</a>  
<br />
+<a href="http://www.apache.org/foundation/thanks.html";>sponsors</a>    </p>
+<iframe
+    src="http://www.apache.org/ads/button.html";
+    style="border-width:0; float: left"
+    frameborder="0"
+    scrolling="no"
+    width="135"
+    height="135">
+</iframe>
+    </div>
+    
+    <div class="main">
+      <div class="breadcrump" style="font-size: 80%;">
+        <a href="/">Home</a>&nbsp;&raquo&nbsp;<a 
href="/documentation.html">Documentation</a>&nbsp;&raquo&nbsp;<a 
href="/documentation/subprojects.html">Apache Felix Subproject 
Documentation</a>&nbsp;&raquo&nbsp;<a 
href="/documentation/subprojects/apache-felix-dependency-manager.html">Apache 
Felix Dependency Manager 4</a>
+      </div>
+
+      
+      
+      <h1>Apache Felix Dependency Manager - Thread Model</h1>
+      <p>This section gives a brief overview of the default thread model used 
by Dependency Manager, and also explains how to start and handle components 
concurrently.</p>
+<h2 id="default-thread-model">Default thread model</h2>
+<p>By default, Dependency Manager uses a lock-free/single thread model:</p>
+<ul>
+<li>When an external event that influence the state of a Component is taking 
place (for example, when a service dependency on which the Component is 
depending on is registered in the 
+registry by a given thread), then DependencyManager does not perform any 
locking for the handling of the event. Instead of that, a job that will handle 
the event is inserted in an internal 
+lock-free Serial Queue which is internally maintained in each Component.</li>
+<li>All jobs scheduled in the Serial Queue are then executed in FIFO order, by 
the first thread which has triggered the first event. This avoid to use some 
blocking locks in DM internals, and 
+also it simplifies the development of DM components, because all lifecycle 
callbacks (init/start/stop/destroy) and dependency injections are scheduled 
through the Serial Queue: This means 
+that your component is not concurrently called in lifecycle callbacks and in 
dependency injection methods.</li>
+<li>Now let's describe which thread is executing the jobs scheduled in a 
Component Serial Queue: When a job (J1) is scheduled in the queue while it is 
empty, then the current thread becomes 
+the "master" and will immediately execute the Serial Queue tasks 
(synchronously). And if another thread triggers another event concurrently 
while the "master" thread is executing the job J1, 
+then a job (J2) for this new event is just enqueued in the Serial Queue, but 
the other thread returns immediately to the caller, and the job J2 will then be 
executed by the "master" thread 
+(after J1). </li>
+</ul>
+<p>This mechanism allows to serially handle all Component events (service 
dependencies) in FIFO order without maintaining any locks.</p>
+<p>The following diagram illustrates the thread model we just described:</p>
+<p><img src="./diagrams/serial-queue.png" alt="Serial Queue" style="width: 
600px"/></p>
+<h2 id="enabling-parallelism-with-a-componentexecutorfactory">Enabling 
parallelism with a <em>ComponentExecutorFactory</em></h2>
+<p>As described above, all the external events that influence the state of a 
given component are handed by jobs scheduled in the Serial Queue of the 
Component, and the jobs are getting 
+executed serially by a single "master" thread. So usually, bundles are started 
from a single thread, meaning that all Components are then activated 
synchronously.</p>
+<p>But when you register in the OSGi service registry a 
ComponentExecutorFactory, that factory will be used by DependencyManager to 
create an Executor of your choice for each Component, 
+typically a shared threadpool configured by yourself. And all the Component 
Serial Queues will be executed using the Executor returned by the 
getExecutorFor(Component) method. However, 
+jobs scheduled in the Serial Queue of a given Component are still executed one 
at a time, in FIFO order and the Component remains single threaded, and 
independent Components may then each 
+be managed and activated concurrently with respect to each other.</p>
+<p>Here is a diagram which illustrates all this:</p>
+<p><img src="./diagrams/concurrent-serial-queue.png" alt="Concurrent Serial 
Queue" style="width: 600px"/></p>
+<p>If you want to ensure that all Components are initialized after the 
ComponentExecutorFactory is registered in the OSGI registry, you can use the 
"org.apache.felix.dependencymanager.parallel" 
+OSGi system property which specifies the list of components which must wait 
for the ComponentExecutorFactory service. This property value can be set to a 
wildcard ("*"), or a list of 
+components implementation class prefixes (comma separated). So, all components 
whose class name starts with the specified prefixes will be cached until the 
ComponentExecutorFactory service 
+is registered (In this way, it is not necessary to use the StartLevel service 
if you want to ensure that all components are started concurrently).</p>
+<p>Some class name prefixes can also be negated (using "!"), in order to 
exclude some components from the list of components using the 
ComponentExecutorFactory service.</p>
+<p>Notice that if the ComponentExecutorFactory itself and all its dependent 
services are defined using the Dependency Manager API, then you have to list 
the package of such components with a 
+"!" prefix, in order to indicate that those components must not wait for a 
ComponentExecutorFactory service (since they are part of the 
ComponentExecutorFactory implementation !). </p>
+<h3 
id="examples-usage-of-the-orgapachefelixdependencymanagerparallel-property">Examples
 usage of the <em>org.apache.felix.dependencymanager.parallel</em> 
property:</h3>
+<div class="codehilite"><pre><span class="n">org</span><span 
class="p">.</span><span class="n">apache</span><span class="p">.</span><span 
class="n">felix</span><span class="p">.</span><span 
class="n">dependencymanager</span><span class="p">.</span><span 
class="n">parallel</span><span class="p">=</span><span class="o">*</span>   
+     <span class="o">-&gt;</span> <span class="n">means</span> <span 
class="n">all</span> <span class="n">components</span> <span 
class="n">must</span> <span class="n">be</span> <span class="n">cached</span> 
<span class="n">until</span> <span class="n">a</span> <span 
class="n">ComponentExecutorFactory</span> <span class="n">comes</span> <span 
class="n">up</span><span class="p">.</span>
+
+<span class="n">org</span><span class="p">.</span><span 
class="n">apache</span><span class="p">.</span><span 
class="n">felix</span><span class="p">.</span><span 
class="n">dependencymanager</span><span class="p">.</span><span 
class="n">parallel</span><span class="p">=</span><span 
class="n">foo</span><span class="p">.</span><span class="n">bar</span><span 
class="p">,</span> <span class="n">foo</span><span class="p">.</span><span 
class="n">zoo</span>
+     <span class="o">-&gt;</span> <span class="n">means</span> <span 
class="n">only</span> <span class="n">components</span> <span 
class="n">whose</span> <span class="n">implementation</span> <span 
class="n">class</span> <span class="n">names</span> <span class="n">are</span> 
<span class="n">starting</span> <span class="n">with</span> &quot;<span 
class="n">foo</span><span class="p">.</span><span class="n">bar</span>&quot; 
<span class="n">or</span> &quot;<span class="n">foo</span><span 
class="p">.</span><span class="n">zoo</span>&quot; 
+     <span class="n">must</span> <span class="n">be</span> <span 
class="n">handled</span> <span class="n">using</span> <span class="n">an</span> 
<span class="n">Executor</span> <span class="n">returned</span> <span 
class="n">by</span> <span class="n">the</span> <span 
class="n">ComponentExecutorFactory</span> <span class="n">service</span><span 
class="p">.</span> <span class="n">Other</span> <span 
class="n">Components</span>
+     <span class="n">will</span> <span class="n">be</span> <span 
class="n">handled</span> <span class="n">normally</span><span 
class="p">,</span> <span class="n">as</span> <span class="n">when</span> <span 
class="n">there</span> <span class="n">is</span> <span class="n">no</span> 
<span class="n">ComponentExecutorFactory</span> <span 
class="n">available</span><span class="p">.</span>
+
+<span class="n">org</span><span class="p">.</span><span 
class="n">apache</span><span class="p">.</span><span 
class="n">felix</span><span class="p">.</span><span 
class="n">dependencymanager</span><span class="p">.</span><span 
class="n">parallel</span><span class="p">=</span>!<span 
class="n">foo</span><span class="p">.</span><span 
class="n">threadpool</span><span class="p">,</span> <span class="o">*</span>
+     <span class="o">-&gt;</span> <span class="n">means</span> <span 
class="n">all</span> <span class="n">components</span> <span 
class="n">must</span> <span class="n">be</span> <span class="n">delayed</span> 
<span class="n">until</span> <span class="n">the</span> <span 
class="n">ComponentExecutorFactory</span> <span class="n">comes</span> <span 
class="n">up</span><span class="p">,</span> <span class="n">except</span> <span 
class="n">the</span> 
+     <span class="n">components</span> <span class="n">whose</span> <span 
class="n">implementations</span> <span class="n">class</span> <span 
class="n">names</span> <span class="n">are</span> <span 
class="n">starting</span> <span class="n">with</span> &quot;<span 
class="n">foo</span><span class="p">.</span><span 
class="n">threadpool</span>&quot; <span class="n">prefix</span><span 
class="p">).</span>
+</pre></div>
+
+
+<h3 
id="examples-of-a-componentexecutorfactory-that-provides-a-shared-threadpool">Examples
 of a ComponentExecutorFactory that provides a shared threadpool:</h3>
+<p>First, we define the OSGi bundle context system property to enable 
parallelism for all DM Components excepts the one which declares the 
ComponentExecutorFactory:</p>
+<div class="codehilite"><pre><span class="n">org</span><span 
class="p">.</span><span class="n">apache</span><span class="p">.</span><span 
class="n">felix</span><span class="p">.</span><span 
class="n">dependencymanager</span><span class="p">.</span><span 
class="n">parallel</span><span class="p">=</span>!<span 
class="n">com</span><span class="p">.</span><span class="n">acme</span><span 
class="p">.</span><span class="n">management</span><span 
class="p">.</span><span class="n">threadpool</span><span class="p">,</span> 
<span class="o">*</span>
+</pre></div>
+
+
+<p>Next, here is the Activator which declares the ComponentExecutorFactory:</p>
+<div class="codehilite"><pre><span class="kn">package</span> <span 
class="n">com</span><span class="o">.</span><span class="na">acme</span><span 
class="o">.</span><span class="na">management</span><span 
class="o">.</span><span class="na">threadpool</span><span class="o">;</span>
+<span class="kn">import</span> <span 
class="nn">org.apache.felix.dm.*</span><span class="o">;</span>
+
+<span class="kd">public</span> <span class="kd">class</span> <span 
class="nc">Activator</span> <span class="kd">extends</span> <span 
class="n">DependencyActivatorBase</span> <span class="o">{</span>      
+   <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">init</span><span class="o">(</span><span 
class="n">BundleContext</span> <span class="n">context</span><span 
class="o">,</span> <span class="n">DependencyManager</span> <span 
class="n">mgr</span><span class="o">)</span> <span class="kd">throws</span> 
<span class="n">Exception</span> <span class="o">{</span>
+      <span class="n">mgr</span><span class="o">.</span><span 
class="na">add</span><span class="o">(</span><span 
class="n">createComponent</span><span class="o">()</span>
+         <span class="o">.</span><span class="na">setInterface</span><span 
class="o">(</span><span class="n">ComponentExecutorFactory</span><span 
class="o">.</span><span class="na">class</span><span class="o">.</span><span 
class="na">getName</span><span class="o">(),</span> <span 
class="kc">null</span><span class="o">)</span>
+         <span class="o">.</span><span 
class="na">setImplementation</span><span class="o">(</span><span 
class="n">ComponentExecutorFactoryImpl</span><span class="o">.</span><span 
class="na">class</span><span class="o">)</span>
+         <span class="o">.</span><span class="na">add</span><span 
class="o">(</span><span class="n">createConfigurationDependency</span><span 
class="o">()</span>
+              <span class="o">.</span><span class="na">setPid</span><span 
class="o">(</span><span 
class="s">&quot;com.acme.management.threadpool.ComponentExecutorFactoryImpl&quot;</span><span
 class="o">)));</span>
+   <span class="o">}</span>
+<span class="o">}</span>
+</pre></div>
+
+
+<p>And here is the implementation for our ComponentExecutorFactory:</p>
+<div class="codehilite"><pre>   <span class="n">package</span> <span 
class="n">com</span><span class="p">.</span><span class="n">acme</span><span 
class="p">.</span><span class="n">management</span><span 
class="p">.</span><span class="n">threadpool</span><span class="p">;</span>
+   <span class="n">import</span> <span class="n">org</span><span 
class="p">.</span><span class="n">apache</span><span class="p">.</span><span 
class="n">felix</span><span class="p">.</span><span class="n">dm</span><span 
class="p">.</span><span class="n">ComponentExecutorFactory</span><span 
class="p">;</span>
+
+   <span class="n">public</span> <span class="n">class</span> <span 
class="n">ComponentExecutorFactoryImpl</span> <span class="n">implements</span> 
<span class="n">ComponentExecutorFactory</span> <span class="p">{</span>
+      <span class="n">volatile</span> <span class="n">Executor</span> <span 
class="n">m_sharedThreadPool</span><span class="p">;</span>
+
+      <span class="n">void</span> <span class="n">updated</span><span 
class="p">(</span><span class="n">Dictionary</span> <span 
class="n">conf</span><span class="p">)</span> <span class="p">{</span>
+          <span class="n">m_sharedThreadPool</span> <span class="p">=</span> 
<span class="n">Executors</span><span class="p">.</span><span 
class="n">newFixedThreadPool</span><span class="p">(</span><span 
class="n">Integer</span><span class="p">.</span><span 
class="n">parseInt</span><span class="p">(</span>&quot;<span 
class="n">threadpool</span><span class="p">.</span><span 
class="nb">size</span>&quot;<span class="p">));</span>
+      <span class="p">}</span>
+
+      <span class="p">@</span><span class="n">Override</span>
+      <span class="n">public</span> <span class="n">Executor</span> <span 
class="n">getExecutorFor</span><span class="p">(</span><span 
class="n">Component</span> <span class="n">component</span><span 
class="p">)</span> <span class="p">{</span>
+          <span class="k">return</span> <span 
class="n">m_sharedThreadPool</span><span class="p">;</span> <span 
class="o">//</span> <span class="n">Use</span> <span class="n">a</span> <span 
class="n">shared</span> <span class="n">threadpool</span> <span 
class="k">for</span> <span class="n">all</span> <span 
class="n">Components</span>
+      <span class="p">}</span>
+  <span class="p">}</span>
+</pre></div>
+
+
+<p>You will find a live example in the source distribution <a 
href="https://svn.apache.org/repos/asf/felix/trunk/dependencymanager/org.apache.felix.dependencymanager.samples/";>sample
 codes</a>:</p>
+<ul>
+<li><a 
href="https://svn.apache.org/repos/asf/felix/trunk/dependencymanager/org.apache.felix.dependencymanager.samples/bnd.bnd";>see
 the bnd.bnd</a> which configures the 
org.apache.felix.dependencymanager.parallel in the <em>-runproperties</em> 
option.</li>
+<li><a 
href="https://svn.apache.org/repos/asf/felix/trunk/dependencymanager/org.apache.felix.dependencymanager.samples/src/org/apache/felix/dependencymanager/samples/tpool/";>see
 the executor factory</a> sample code and README file to up-to-date 
informations.</li>
+</ul>
+      <div class="timestamp" style="margin-top: 30px; font-size: 80%; 
text-align: right;">
+        Rev. 1665537 by pderop on Tue, 10 Mar 2015 13:30:25 +0000
+      </div>
+      <div class="trademarkFooter"> 
+        Apache Felix, Felix, Apache, the Apache feather logo, and the Apache 
Felix project
+        logo are trademarks of The Apache Software Foundation. All other marks 
mentioned
+        may be trademarks or registered trademarks of their respective owners.
+      </div>
+    </div>
+  </body>
+</html>

Added: 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/tutorials/getting-started.html
==============================================================================
--- 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/tutorials/getting-started.html
 (added)
+++ 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/tutorials/getting-started.html
 Tue Mar 10 21:03:25 2015
@@ -0,0 +1,245 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
"http://www.w3.org/TR/html4/loose.dtd";>
+<html>
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You under the Apache License, Version 2.0
+    (the "License"); you may not use this file except in compliance with
+    the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE- 2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+  <head>
+    <title>Apache Felix - Apache Felix Dependency Manager - Getting 
Started</title>
+    <link rel="icon" href="/res/favicon.ico">
+    <link rel="stylesheet" href="/res/site.css" type="text/css" media="all">
+    <link rel="stylesheet" href="/res/codehilite.css" type="text/css" 
media="all">
+    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+  </head>
+  <body>
+    <div class="title">
+      <div class="logo">
+        <a href="http://felix.apache.org/";>
+          <img border="0" alt="Apache Felix" src="/res/logo.png">
+        </a>
+      </div>
+      <div class="header">
+        <a href="http://www.apache.org/";>
+          <img border="0" alt="Apache" src="/res/apache.png">
+        </a>
+      </div>
+    </div>
+    
+    <div class="menu"> 
+      <p><a href="/news.html">news</a>  <br />
+<a href="/license.html">license</a>  <br />
+<a href="/downloads.cgi">downloads</a>  <br />
+<a href="/documentation.html">documentation</a>  <br />
+<a href="/mailinglists.html">mailing lists</a>  <br />
+<a href="/documentation/community/contributing.html">contributing</a>  <br />
+<a href="/sitemap.html">site map</a>  <br />
+<a href="http://www.apache.org/";>asf</a>  <br />
+<a href="http://www.apache.org/security/";>security</a>  <br />
+<a href="http://www.apache.org/foundation/sponsorship.html";>sponsorship</a>  
<br />
+<a href="http://www.apache.org/foundation/thanks.html";>sponsors</a>    </p>
+<iframe
+    src="http://www.apache.org/ads/button.html";
+    style="border-width:0; float: left"
+    frameborder="0"
+    scrolling="no"
+    width="135"
+    height="135">
+</iframe>
+    </div>
+    
+    <div class="main">
+      <div class="breadcrump" style="font-size: 80%;">
+        <a href="/">Home</a>&nbsp;&raquo&nbsp;<a 
href="/documentation.html">Documentation</a>&nbsp;&raquo&nbsp;<a 
href="/documentation/subprojects.html">Apache Felix Subproject 
Documentation</a>&nbsp;&raquo&nbsp;<a 
href="/documentation/subprojects/apache-felix-dependency-manager.html">Apache 
Felix Dependency Manager 4</a>
+      </div>
+
+      
+      
+      <h1>Apache Felix Dependency Manager - Getting Started</h1>
+      <h2 id="getting-started">Getting Started</h2>
+<p>When developing an OSGi bundle that has dependencies and possibly registers 
services, there are two classes in particular we need to implement:</p>
+<ol>
+<li>The bundle activator which controls the life-cycle of the bundle.</li>
+<li>The actual component, which can be a POJO.</li>
+</ol>
+<p>When using the dependency manager, your bundle activator is a subclass of 
<code>DependencyActivatorBase</code>. It needs to implement the 
<code>init</code> life cycle method and can optionally also implement a 
<code>destroy</code> method. Both methods take two arguments: 
<code>BundleContext</code> and <code>DependencyManager</code>. The latter is 
your interface to the declarative API you can use to define your components and 
dependencies.</p>
+<p>The following paragraphs will show various examples that explain how to do 
this. Subsequently, some more advanced scenarios will be covered that involve 
listening to dependency and component state changes and interacting with the 
OSGi framework from within your component implementation.</p>
+<p>To use the dependency manager, you should put the 
<code>org.apache.felix.dependencymanager.jar</code> in your classpath while 
compiling and in your OSGi framework when running.</p>
+<h3 id="registering-a-service">Registering a service</h3>
+<p>The first example is about registering a service. We extend 
<code>DependencyActivatorBase</code> and in the <code>init</code> method we use 
the reference to the <code>DependencyManager</code> to create and add a 
component. For this component we subsequently set its service interface and 
implementation. In this case the interface is the <code>Store</code> interface, 
the second parameter, <code>null</code>, allows you to provide properties along 
with the service registration. For the implementation, we only mention the 
<code>Class</code> of the implementation, which means the dependency manager 
will lazily instantiate it. In this case, there is not much point in doing that 
because the component has no dependencies, but if it had, the instantiation 
would only happen when those dependencies were resolved.</p>
+<p>Notice that the dependency manager API uses method chaining to create a 
more or less "fluent" API that, with proper indentation, is very easy to 
read.</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">class</span> <span class="n">Activator</span> <span 
class="n">extends</span> <span class="n">DependencyActivatorBase</span> <span 
class="p">{</span>
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">init</span><span class="p">(</span><span 
class="n">BundleContext</span> <span class="n">context</span><span 
class="p">,</span> <span class="n">DependencyManager</span> <span 
class="n">manager</span><span class="p">)</span> <span class="n">throws</span> 
<span class="n">Exception</span> <span class="p">{</span>
+        <span class="n">manager</span><span class="p">.</span><span 
class="n">add</span><span class="p">(</span><span 
class="n">createComponent</span><span class="p">()</span>
+            <span class="p">.</span><span class="n">setInterface</span><span 
class="p">(</span><span class="n">Store</span><span class="p">.</span><span 
class="n">class</span><span class="p">.</span><span 
class="n">getName</span><span class="p">(),</span> <span 
class="n">null</span><span class="p">)</span>
+            <span class="p">.</span><span 
class="n">setImplementation</span><span class="p">(</span><span 
class="n">MemoryStore</span><span class="p">.</span><span 
class="n">class</span><span class="p">)</span>
+        <span class="p">);</span>
+    <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>This is the service interface. Nothing special here.</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">interface</span> <span class="n">Store</span> <span class="p">{</span>
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">put</span><span class="p">(</span><span class="n">String</span> <span 
class="n">key</span><span class="p">,</span> <span class="n">Object</span> 
<span class="n">value</span><span class="p">);</span>
+    <span class="n">public</span> <span class="n">Object</span> <span 
class="n">get</span><span class="p">(</span><span class="n">String</span> <span 
class="n">key</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>And finally the implementation. Again, this is just a POJO, there is no 
reference here to any OSGi or dependency manager specific class or 
annotation.</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">class</span> <span class="n">MemoryStore</span> <span 
class="n">implements</span> <span class="n">Store</span> <span 
class="p">{</span>
+    <span class="n">private</span> <span class="n">Map</span> <span 
class="n">m_map</span> <span class="p">=</span> <span class="n">new</span> 
<span class="n">HashMap</span><span class="p">();</span>
+
+    <span class="n">public</span> <span class="n">Object</span> <span 
class="n">get</span><span class="p">(</span><span class="n">String</span> <span 
class="n">key</span><span class="p">)</span> <span class="p">{</span>
+        <span class="k">return</span> <span class="n">m_map</span><span 
class="p">.</span><span class="n">get</span><span class="p">(</span><span 
class="n">key</span><span class="p">);</span>
+    <span class="p">}</span>
+
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">put</span><span class="p">(</span><span class="n">String</span> <span 
class="n">key</span><span class="p">,</span> <span class="n">Object</span> 
<span class="n">value</span><span class="p">)</span> <span class="p">{</span>
+        <span class="n">m_map</span><span class="p">.</span><span 
class="n">put</span><span class="p">(</span><span class="n">key</span><span 
class="p">,</span> <span class="n">value</span><span class="p">);</span>
+    <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<h3 id="depending-on-a-service">Depending on a service</h3>
+<p>Our second example is that of a component that depends on two other 
services: our <code>Store</code> from the previous example and the standard 
OSGi <code>LogService</code>. Looking at the code, there is a small but 
important difference between the two: <code>Store</code> is a required 
dependency and <code>LogService</code> is not. This means that our component 
really needs a store to work, but if there is no logging available, it can work 
without. Also note that this component has no <code>setInterface</code> method, 
which simply means it is not itself a service. This is perfectly fine.</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">class</span> <span class="n">Activator</span> <span 
class="n">extends</span> <span class="n">DependencyActivatorBase</span> <span 
class="p">{</span>
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">init</span><span class="p">(</span><span 
class="n">BundleContext</span> <span class="n">context</span><span 
class="p">,</span> <span class="n">DependencyManager</span> <span 
class="n">manager</span><span class="p">)</span> <span class="n">throws</span> 
<span class="n">Exception</span> <span class="p">{</span>
+        <span class="n">manager</span><span class="p">.</span><span 
class="n">add</span><span class="p">(</span><span 
class="n">createComponent</span><span class="p">()</span>
+            <span class="p">.</span><span 
class="n">setImplementation</span><span class="p">(</span><span 
class="n">DataGenerator</span><span class="p">.</span><span 
class="n">class</span><span class="p">)</span>
+            <span class="p">.</span><span class="n">add</span><span 
class="p">(</span><span class="n">createServiceDependency</span><span 
class="p">()</span>
+                <span class="p">.</span><span class="n">setService</span><span 
class="p">(</span><span class="n">Store</span><span class="p">.</span><span 
class="n">class</span><span class="p">)</span>
+                <span class="p">.</span><span 
class="n">setRequired</span><span class="p">(</span><span 
class="n">true</span><span class="p">)</span>
+            <span class="p">)</span>
+            <span class="p">.</span><span class="n">add</span><span 
class="p">(</span><span class="n">createServiceDependency</span><span 
class="p">()</span>
+                <span class="p">.</span><span class="n">setService</span><span 
class="p">(</span><span class="n">LogService</span><span 
class="p">.</span><span class="n">class</span><span class="p">)</span>
+                <span class="p">.</span><span 
class="n">setRequired</span><span class="p">(</span><span 
class="n">false</span><span class="p">)</span>
+            <span class="p">)</span>
+        <span class="p">);</span>
+    <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>Now let's look at our POJO. There are a couple of interesting things to 
explain. First of all, our dependencies are declared as fields, and they don't 
even have setters (or getters). When the dependency manager instantiates our 
class, it will (through reflection) inject the dependencies so they are just 
available for our class to use. That is also the reason these fields are 
declared as volatile: to make sure they are visible to all threads traversing 
our instance.</p>
+<p>One final note, since we defined our <code>LogService</code> dependency as 
optional, it might not be available when we invoke it. Still, the code does not 
contain any checks to avoid a null pointer exception. It does not need to, 
since the dependency manager makes sure to inject a null object when the real 
service is not available. The null object can be invoked and will do nothing. 
For a lot of cases that is good enough, but for those cases where it is not, 
our next example introduces callbacks that notify you of changes.</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">class</span> <span class="n">DataGenerator</span> <span 
class="p">{</span>
+    <span class="n">private</span> <span class="n">volatile</span> <span 
class="n">Store</span> <span class="n">m_store</span><span class="p">;</span>
+    <span class="n">private</span> <span class="n">volatile</span> <span 
class="n">LogService</span> <span class="n">m_log</span><span class="p">;</span>
+
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">generate</span><span class="p">()</span> <span class="p">{</span>
+        <span class="k">for</span> <span class="p">(</span><span 
class="n">int</span> <span class="nb">i</span> <span class="p">=</span> 0<span 
class="p">;</span> <span class="nb">i</span> <span class="o">&lt;</span> 
10<span class="p">;</span> <span class="nb">i</span><span 
class="o">++</span><span class="p">)</span> <span class="p">{</span>
+            <span class="n">m_store</span><span class="p">.</span><span 
class="n">put</span><span class="p">(</span>&quot;#&quot; <span 
class="o">+</span> <span class="nb">i</span><span class="p">,</span> 
&quot;<span class="n">value_</span>&quot; <span class="o">+</span> <span 
class="nb">i</span><span class="p">);</span>
+        <span class="p">}</span>
+        <span class="n">m_log</span><span class="p">.</span><span 
class="nb">log</span><span class="p">(</span><span 
class="n">LogService</span><span class="p">.</span><span 
class="n">LOG_INFO</span><span class="p">,</span> &quot;<span 
class="n">Data</span> <span class="n">generated</span><span 
class="p">.</span>&quot;<span class="p">);</span>
+    <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<h3 id="tracking-services-with-callbacks">Tracking services with callbacks</h3>
+<p>Sometimes, simply injecting services does not give you enough control over 
a dependency because you might want to track more than one, or you might want 
to execute some code on changes. For all those cases, callbacks are your 
friends. Since one of our goals is to not introduce any kind of API in our 
POJO, callbacks are declared by specifying their method names instead of 
through some interface. In this case, we have a dependency on 
<code>Translator</code> services, and we define <code>added</code> and 
<code>removed</code> as callbacks.</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">class</span> <span class="n">Activator</span> <span 
class="n">extends</span> <span class="n">DependencyActivatorBase</span> <span 
class="p">{</span>
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">init</span><span class="p">(</span><span 
class="n">BundleContext</span> <span class="n">context</span><span 
class="p">,</span> <span class="n">DependencyManager</span> <span 
class="n">manager</span><span class="p">)</span> <span class="n">throws</span> 
<span class="n">Exception</span> <span class="p">{</span>
+        <span class="n">manager</span><span class="p">.</span><span 
class="n">add</span><span class="p">(</span><span 
class="n">createComponent</span><span class="p">()</span>
+            <span class="p">.</span><span 
class="n">setImplementation</span><span class="p">(</span><span 
class="n">DocumentTranslator</span><span class="p">.</span><span 
class="n">class</span><span class="p">)</span>
+            <span class="p">.</span><span class="n">add</span><span 
class="p">(</span><span class="n">createServiceDependency</span><span 
class="p">()</span>
+                <span class="p">.</span><span class="n">setService</span><span 
class="p">(</span><span class="n">Translator</span><span 
class="p">.</span><span class="n">class</span><span class="p">)</span>
+                <span class="p">.</span><span 
class="n">setRequired</span><span class="p">(</span><span 
class="n">false</span><span class="p">)</span>
+                <span class="p">.</span><span 
class="n">setCallbacks</span><span class="p">(</span>&quot;<span 
class="n">added</span>&quot;<span class="p">,</span> &quot;<span 
class="n">removed</span>&quot;<span class="p">)</span>
+            <span class="p">)</span>
+        <span class="p">);</span>
+    <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>This is the actual <code>Translator</code> service, which, for the purpose 
of this example, is not that important.</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">interface</span> <span class="n">Translator</span> <span 
class="p">{</span>
+    <span class="n">public</span> <span class="n">boolean</span> <span 
class="n">canTranslate</span><span class="p">(</span><span 
class="n">String</span> <span class="n">from</span><span class="p">,</span> 
<span class="n">String</span> <span class="n">to</span><span class="p">);</span>
+    <span class="n">public</span> <span class="n">Document</span> <span 
class="n">translate</span><span class="p">(</span><span 
class="n">Document</span> <span class="n">document</span><span 
class="p">,</span> <span class="n">String</span> <span 
class="n">from</span><span class="p">,</span> <span class="n">String</span> 
<span class="n">to</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>Finally, here's our implementation. It declares the callback methods with 
one parameter: the <code>Translator</code> service. Actually, the dependency 
manager will look for several different signatures (all explained in more 
detail in the reference section).</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">class</span> <span class="n">DocumentTranslator</span> <span 
class="p">{</span>
+    <span class="n">private</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">Translator</span><span 
class="o">&gt;</span> <span class="n">m_translators</span> <span 
class="p">=</span> <span class="n">new</span> <span 
class="n">ArrayList</span><span class="o">&lt;</span><span 
class="n">Translator</span><span class="o">&gt;</span><span class="p">();</span>
+
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">added</span><span class="p">(</span><span class="n">Translator</span> 
<span class="n">translator</span><span class="p">)</span> <span 
class="p">{</span>
+        <span class="n">m_translators</span><span class="p">.</span><span 
class="n">add</span><span class="p">(</span><span 
class="n">translator</span><span class="p">);</span>
+    <span class="p">}</span>
+
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">removed</span><span class="p">(</span><span 
class="n">Translator</span> <span class="n">translator</span><span 
class="p">)</span> <span class="p">{</span>
+        <span class="n">m_translators</span><span class="p">.</span><span 
class="n">remove</span><span class="p">(</span><span 
class="n">translator</span><span class="p">);</span>
+    <span class="p">}</span>
+
+    <span class="n">public</span> <span class="n">Document</span> <span 
class="n">translate</span><span class="p">(</span><span 
class="n">Document</span> <span class="n">document</span><span 
class="p">,</span> <span class="n">String</span> <span 
class="n">from</span><span class="p">,</span> <span class="n">String</span> 
<span class="n">to</span><span class="p">)</span> <span class="p">{</span>
+        <span class="k">for</span> <span class="p">(</span><span 
class="n">Translator</span> <span class="n">translator</span> <span 
class="p">:</span> <span class="n">m_translators</span><span class="p">)</span> 
<span class="p">{</span>
+            <span class="k">if</span> <span class="p">(</span><span 
class="n">translator</span><span class="p">.</span><span 
class="n">canTranslate</span><span class="p">(</span><span 
class="n">from</span><span class="p">,</span> <span class="n">to</span><span 
class="p">))</span> <span class="p">{</span>
+                <span class="k">return</span> <span 
class="n">translator</span><span class="p">.</span><span 
class="n">translate</span><span class="p">(</span><span 
class="n">document</span><span class="p">,</span> <span 
class="n">from</span><span class="p">,</span> <span class="n">to</span><span 
class="p">);</span>
+            <span class="p">}</span>
+        <span class="p">}</span>
+        <span class="k">return</span> <span class="n">null</span><span 
class="p">;</span>
+    <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<h3 id="depending-on-a-configuration">Depending on a configuration</h3>
+<p>Not all dependencies are on services. There are several other types of 
dependencies that are supported, one of them is the configuration dependency. 
In fact, only <em>required</em> configuration dependencies are supported, 
because optional ones can just be achieved by registering as a 
<code>ManagedService</code> yourself. When defining the dependency, you must 
define the persistent ID of the service. The component will not become active 
until the configuration you depend on is available <em>and</em> is valid. The 
latter can be checked by your implementation as we will see below.</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">class</span> <span class="n">Activator</span> <span 
class="n">extends</span> <span class="n">DependencyActivatorBase</span> <span 
class="p">{</span>
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">init</span><span class="p">(</span><span 
class="n">BundleContext</span> <span class="n">context</span><span 
class="p">,</span> <span class="n">DependencyManager</span> <span 
class="n">manager</span><span class="p">)</span> <span class="n">throws</span> 
<span class="n">Exception</span> <span class="p">{</span>
+        <span class="n">manager</span><span class="p">.</span><span 
class="n">add</span><span class="p">(</span><span 
class="n">createComponent</span><span class="p">()</span>
+            <span class="p">.</span><span 
class="n">setImplementation</span><span class="p">(</span><span 
class="n">Task</span><span class="p">.</span><span class="n">class</span><span 
class="p">)</span>
+            <span class="p">.</span><span class="n">add</span><span 
class="p">(</span><span class="n">createConfigurationDependency</span><span 
class="p">()</span>
+                <span class="p">.</span><span class="n">setPid</span><span 
class="p">(</span>&quot;<span class="n">config</span><span 
class="p">.</span><span class="n">pid</span>&quot;<span class="p">)</span>
+            <span class="p">)</span>
+        <span class="p">);</span>
+    <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>Here's our code that implements <code>ManagedService</code> and has an 
<code>updated</code> method. This method checks if the provided configuration 
is valid and throw a <code>ConfigurationException</code> if it is not. As long 
as this method does not accept the configuration, the corresponding component 
will not be activated.</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">class</span> <span class="n">Task</span> <span 
class="n">implements</span> <span class="n">ManagedService</span> <span 
class="p">{</span>
+    <span class="n">private</span> <span class="n">String</span> <span 
class="n">m_interval</span><span class="p">;</span>
+
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">execute</span><span class="p">()</span> <span class="p">{</span>
+        <span class="n">System</span><span class="p">.</span><span 
class="n">out</span><span class="p">.</span><span class="n">println</span><span 
class="p">(</span>&quot;<span class="n">Scheduling</span> <span 
class="n">task</span> <span class="n">with</span> <span 
class="n">interval</span> &quot; <span class="o">+</span> <span 
class="n">m_interval</span><span class="p">);</span>
+    <span class="p">}</span>
+
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">updated</span><span class="p">(</span><span 
class="n">Dictionary</span> <span class="k">properties</span><span 
class="p">)</span> <span class="n">throws</span> <span 
class="n">ConfigurationException</span> <span class="p">{</span>
+        <span class="k">if</span> <span class="p">(</span><span 
class="k">properties</span> !<span class="p">=</span> <span 
class="n">null</span><span class="p">)</span> <span class="p">{</span>
+            <span class="n">m_interval</span> <span class="p">=</span> <span 
class="p">(</span><span class="n">String</span><span class="p">)</span> <span 
class="k">properties</span><span class="p">.</span><span 
class="n">get</span><span class="p">(</span>&quot;<span 
class="n">interval</span>&quot;<span class="p">);</span>
+            <span class="k">if</span> <span class="p">(</span><span 
class="n">m_interval</span> <span class="o">==</span> <span 
class="n">null</span><span class="p">)</span> <span class="p">{</span>
+                <span class="n">throw</span> <span class="n">new</span> <span 
class="n">ConfigurationException</span><span class="p">(</span>&quot;<span 
class="n">interval</span>&quot;<span class="p">,</span> &quot;<span 
class="n">must</span> <span class="n">be</span> <span 
class="n">specified</span>&quot;<span class="p">);</span>
+            <span class="p">}</span>
+        <span class="p">}</span>
+    <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+      <div class="timestamp" style="margin-top: 30px; font-size: 80%; 
text-align: right;">
+        Rev. 1664113 by marrs on Wed, 4 Mar 2015 18:52:20 +0000
+      </div>
+      <div class="trademarkFooter"> 
+        Apache Felix, Felix, Apache, the Apache feather logo, and the Apache 
Felix project
+        logo are trademarks of The Apache Software Foundation. All other marks 
mentioned
+        may be trademarks or registered trademarks of their respective owners.
+      </div>
+    </div>
+  </body>
+</html>

Added: 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/tutorials/leveraging-the-shell.html
==============================================================================
--- 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/tutorials/leveraging-the-shell.html
 (added)
+++ 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/tutorials/leveraging-the-shell.html
 Tue Mar 10 21:03:25 2015
@@ -0,0 +1,169 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
"http://www.w3.org/TR/html4/loose.dtd";>
+<html>
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You under the Apache License, Version 2.0
+    (the "License"); you may not use this file except in compliance with
+    the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE- 2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+  <head>
+    <title>Apache Felix - Apache Felix Dependency Manager - Leveraging the 
shell</title>
+    <link rel="icon" href="/res/favicon.ico">
+    <link rel="stylesheet" href="/res/site.css" type="text/css" media="all">
+    <link rel="stylesheet" href="/res/codehilite.css" type="text/css" 
media="all">
+    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+  </head>
+  <body>
+    <div class="title">
+      <div class="logo">
+        <a href="http://felix.apache.org/";>
+          <img border="0" alt="Apache Felix" src="/res/logo.png">
+        </a>
+      </div>
+      <div class="header">
+        <a href="http://www.apache.org/";>
+          <img border="0" alt="Apache" src="/res/apache.png">
+        </a>
+      </div>
+    </div>
+    
+    <div class="menu"> 
+      <p><a href="/news.html">news</a>  <br />
+<a href="/license.html">license</a>  <br />
+<a href="/downloads.cgi">downloads</a>  <br />
+<a href="/documentation.html">documentation</a>  <br />
+<a href="/mailinglists.html">mailing lists</a>  <br />
+<a href="/documentation/community/contributing.html">contributing</a>  <br />
+<a href="/sitemap.html">site map</a>  <br />
+<a href="http://www.apache.org/";>asf</a>  <br />
+<a href="http://www.apache.org/security/";>security</a>  <br />
+<a href="http://www.apache.org/foundation/sponsorship.html";>sponsorship</a>  
<br />
+<a href="http://www.apache.org/foundation/thanks.html";>sponsors</a>    </p>
+<iframe
+    src="http://www.apache.org/ads/button.html";
+    style="border-width:0; float: left"
+    frameborder="0"
+    scrolling="no"
+    width="135"
+    height="135">
+</iframe>
+    </div>
+    
+    <div class="main">
+      <div class="breadcrump" style="font-size: 80%;">
+        <a href="/">Home</a>&nbsp;&raquo&nbsp;<a 
href="/documentation.html">Documentation</a>&nbsp;&raquo&nbsp;<a 
href="/documentation/subprojects.html">Apache Felix Subproject 
Documentation</a>&nbsp;&raquo&nbsp;<a 
href="/documentation/subprojects/apache-felix-dependency-manager.html">Apache 
Felix Dependency Manager 4</a>
+      </div>
+
+      
+      
+      <h1>Apache Felix Dependency Manager - Leveraging the shell</h1>
+      <h1 id="introduction">Introduction</h1>
+<p>The shell bundle for the dependency manager extends the gogo shell with one 
new command called "dm". This command can be used to get insight in the actual 
components and services in a running OSGi framework.</p>
+<p>Typing help <code>help dm</code> in the gogo shell gives an overview of the 
available command options.</p>
+<div class="codehilite"><pre><span class="n">dm</span> <span 
class="o">-</span> <span class="n">List</span> <span 
class="n">dependency</span> <span class="n">manager</span> <span 
class="n">components</span>
+   <span class="n">scope</span><span class="p">:</span> <span 
class="n">dependencymanager</span>
+   <span class="n">flags</span><span class="p">:</span>
+      <span class="n">compact</span><span class="p">,</span> <span 
class="n">cp</span>       <span class="n">Displays</span> <span 
class="n">components</span> <span class="n">using</span> <span 
class="n">a</span> <span class="n">compact</span> <span class="n">form</span>
+      <span class="n">nodeps</span><span class="p">,</span> <span 
class="n">nd</span>        <span class="n">Hides</span> <span 
class="n">component</span> <span class="n">dependencies</span>
+      <span class="n">notavail</span><span class="p">,</span> <span 
class="n">na</span>      <span class="n">Only</span> <span 
class="n">displays</span> <span class="n">unavailable</span> <span 
class="n">components</span>
+      <span class="n">stats</span><span class="p">,</span> <span 
class="n">stat</span><span class="p">,</span> <span class="n">st</span>   <span 
class="n">Displays</span> <span class="n">components</span> <span 
class="n">statistics</span>
+      <span class="n">wtf</span>               <span class="n">Detects</span> 
<span class="n">where</span> <span class="n">are</span> <span 
class="n">the</span> <span class="n">root</span> <span class="n">failures</span>
+   <span class="n">options</span><span class="p">:</span>
+      <span class="n">bundleIds</span><span class="p">,</span> <span 
class="n">bid</span><span class="p">,</span> <span class="n">bi</span><span 
class="p">,</span> <span class="n">b</span> <span class="o">&lt;</span><span 
class="n">List</span> <span class="n">of</span> <span class="n">bundle</span> 
<span class="n">ids</span> <span class="n">or</span> <span 
class="n">bundle</span> <span class="n">symbolic</span>
+          <span class="n">names</span> <span class="n">to</span> <span 
class="n">display</span> <span class="p">(</span><span class="n">comma</span> 
<span class="n">separated</span><span class="p">)</span><span 
class="o">&gt;</span> <span class="p">[</span><span 
class="n">optional</span><span class="p">]</span>
+      <span class="n">componentIds</span><span class="p">,</span> <span 
class="n">cid</span><span class="p">,</span> <span class="n">ci</span> <span 
class="o">&lt;</span><span class="n">List</span> <span class="n">of</span> 
<span class="n">component</span> <span class="n">identifiers</span> <span 
class="n">to</span> <span class="n">display</span>
+          <span class="p">(</span><span class="n">comma</span> <span 
class="n">separated</span><span class="p">)</span><span class="o">&gt;</span> 
<span class="p">[</span><span class="n">optional</span><span class="p">]</span>
+      <span class="n">components</span><span class="p">,</span> <span 
class="n">c</span> <span class="o">&lt;</span><span class="n">Regex</span><span 
class="p">(</span><span class="n">s</span><span class="p">)</span> <span 
class="n">used</span> <span class="n">to</span> <span class="n">filter</span> 
<span class="n">on</span> <span class="n">component</span>
+          <span class="n">implementation</span> <span class="n">class</span> 
<span class="n">names</span> <span class="p">(</span><span 
class="n">comma</span> <span class="n">separated</span><span 
class="p">),</span> <span class="n">can</span> <span class="n">be</span>
+          <span class="n">negated</span> <span class="n">using</span> 
&quot;!&quot; <span class="n">prefix</span><span class="o">&gt;</span> <span 
class="p">[</span><span class="n">optional</span><span class="p">]</span>
+      <span class="n">services</span><span class="p">,</span> <span 
class="n">s</span> <span class="o">&lt;</span><span class="n">OSGi</span> <span 
class="n">filter</span> <span class="n">used</span> <span class="n">to</span> 
<span class="n">filter</span> <span class="n">some</span> <span 
class="n">service</span> 
+          <span class="k">properties</span><span class="o">&gt;</span> <span 
class="p">[</span><span class="n">optional</span><span class="p">]</span>
+      <span class="n">top</span> <span class="o">&lt;</span><span 
class="n">Max</span> <span class="n">number</span> <span class="n">of</span> 
<span class="n">top</span> <span class="n">components</span> <span 
class="n">to</span> <span class="n">display</span> <span 
class="p">(</span>0<span class="p">=</span><span class="n">all</span><span 
class="p">)</span><span class="o">&gt;</span> <span class="n">This</span>
+          <span class="n">command</span> <span class="n">displays</span> <span 
class="n">components</span> <span class="n">callbacks</span> <span 
class="p">(</span><span class="n">init</span><span class="o">/</span><span 
class="n">start</span><span class="p">)</span>
+          <span class="n">times</span><span class="o">&gt;</span> <span 
class="p">[</span><span class="n">optional</span><span class="p">]</span>
+   <span class="n">parameters</span><span class="p">:</span>
+      <span class="n">CommandSession</span>
+</pre></div>
+
+
+<h1 id="usage-examples">Usage examples</h1>
+<p>Below are some examples for typical usage of the dependency manager shell 
commands. The examples are based on a simple component model with a dashboard 
which has a required dependency on four probes (temperature, humidity, 
radiation, pressure). The radiation probe requires a Sensor service but this 
sensor is not available.</p>
+<p><strong>List all dependency manager components</strong></p>
+<p><code>dm</code></p>
+<p>Sample output:</p>
+<div class="codehilite"><pre><span class="p">[</span>9<span class="p">]</span> 
<span class="n">dm</span><span class="p">.</span><span class="n">demo</span>
+ <span class="p">[</span>6<span class="p">]</span> <span 
class="n">dm</span><span class="p">.</span><span class="n">demo</span><span 
class="p">.</span><span class="n">Probe</span><span class="p">(</span><span 
class="n">type</span><span class="p">=</span><span 
class="n">radiation</span><span class="p">)</span> <span 
class="n">unregistered</span>
+    <span class="n">dm</span><span class="p">.</span><span 
class="n">demo</span><span class="p">.</span><span class="n">Sensor</span> 
<span class="n">service</span> <span class="n">required</span> <span 
class="n">unavailable</span>
+ <span class="p">[</span>7<span class="p">]</span> <span 
class="n">dm</span><span class="p">.</span><span class="n">demo</span><span 
class="p">.</span><span class="n">Probe</span><span class="p">(</span><span 
class="n">type</span><span class="p">=</span><span 
class="n">humidity</span><span class="p">)</span> <span 
class="n">registered</span>
+ <span class="p">[</span>9<span class="p">]</span> <span 
class="n">dm</span><span class="p">.</span><span class="n">demo</span><span 
class="p">.</span><span class="n">impl</span><span class="p">.</span><span 
class="n">Dashboard</span> <span class="n">unregistered</span>
+    <span class="n">dm</span><span class="p">.</span><span 
class="n">demo</span><span class="p">.</span><span class="n">Probe</span> <span 
class="p">(</span><span class="n">type</span><span class="p">=</span><span 
class="n">temperature</span><span class="p">)</span> <span 
class="n">service</span> <span class="n">required</span> <span 
class="n">available</span>
+    <span class="n">dm</span><span class="p">.</span><span 
class="n">demo</span><span class="p">.</span><span class="n">Probe</span> <span 
class="p">(</span><span class="n">type</span><span class="p">=</span><span 
class="n">radiation</span><span class="p">)</span> <span 
class="n">service</span> <span class="n">required</span> <span 
class="n">unavailable</span>
+    <span class="n">dm</span><span class="p">.</span><span 
class="n">demo</span><span class="p">.</span><span class="n">Probe</span> <span 
class="p">(</span><span class="n">type</span><span class="p">=</span><span 
class="n">humidity</span><span class="p">)</span> <span 
class="n">service</span> <span class="n">required</span> <span 
class="n">available</span>
+    <span class="n">dm</span><span class="p">.</span><span 
class="n">demo</span><span class="p">.</span><span class="n">Probe</span> <span 
class="p">(</span><span class="n">type</span><span class="p">=</span><span 
class="n">pressure</span><span class="p">)</span> <span 
class="n">service</span> <span class="n">required</span> <span 
class="n">available</span>
+ <span class="p">[</span>5<span class="p">]</span> <span 
class="n">dm</span><span class="p">.</span><span class="n">demo</span><span 
class="p">.</span><span class="n">Probe</span><span class="p">(</span><span 
class="n">type</span><span class="p">=</span><span 
class="n">temperature</span><span class="p">)</span> <span 
class="n">registered</span>
+ <span class="p">[</span>8<span class="p">]</span> <span 
class="n">dm</span><span class="p">.</span><span class="n">demo</span><span 
class="p">.</span><span class="n">Probe</span><span class="p">(</span><span 
class="n">type</span><span class="p">=</span><span 
class="n">pressure</span><span class="p">)</span> <span 
class="n">registered</span>
+</pre></div>
+
+
+<p>All components are listed including the dependencies and the availability 
of these dependencies. The top level element is the bundle and below are the 
components registered with that bundle's bundle context. The lowest level is 
that of the component's dependencies. </p>
+<div class="codehilite"><pre><span class="p">[</span><span 
class="n">bundleid</span><span class="p">]</span> <span class="n">bundle</span>
+    <span class="p">[</span><span class="n">component</span> <span 
class="n">id</span><span class="p">]</span> <span class="n">component</span> 
<span class="n">interfaces</span> <span class="p">(</span><span 
class="n">service</span> <span class="k">properties</span><span 
class="p">)</span>
+        <span class="n">dependency</span> <span class="o">&lt;</span><span 
class="n">availability</span><span class="o">&gt;</span>
+</pre></div>
+
+
+<p>The following flags can be used to tailor the output:</p>
+<ul>
+<li><code>compact, cp</code> shortens package names and dependencies and 
therefore gives a more compressed output.</li>
+<li><code>nodeps, nd</code> omits the dependencies from the output.</li>
+<li><code>notavail, na</code> filters out all components that are registered 
wich results in the output only containing those components that are in the 
unregistered state due to one or more unsatisfied required dependencies. This 
is the command option most used when using the dependency manager shell 
commands.</li>
+</ul>
+<p>Sample output for <code>dm na</code>:</p>
+<div class="codehilite"><pre><span class="p">[</span>9<span class="p">]</span> 
<span class="n">dm</span><span class="p">.</span><span class="n">demo</span>
+ <span class="p">[</span>14<span class="p">]</span> <span 
class="n">dm</span><span class="p">.</span><span class="n">demo</span><span 
class="p">.</span><span class="n">impl</span><span class="p">.</span><span 
class="n">Dashboard</span> <span class="n">unregistered</span>
+    <span class="n">dm</span><span class="p">.</span><span 
class="n">demo</span><span class="p">.</span><span class="n">Probe</span> <span 
class="p">(</span><span class="n">type</span><span class="p">=</span><span 
class="n">radiation</span><span class="p">)</span> <span 
class="n">service</span> <span class="n">required</span> <span 
class="n">unavailable</span>
+ <span class="p">[</span>11<span class="p">]</span> <span 
class="n">dm</span><span class="p">.</span><span class="n">demo</span><span 
class="p">.</span><span class="n">Probe</span><span class="p">(</span><span 
class="n">type</span><span class="p">=</span><span 
class="n">radiation</span><span class="p">)</span> <span 
class="n">unregistered</span>
+    <span class="n">dm</span><span class="p">.</span><span 
class="n">demo</span><span class="p">.</span><span class="n">Sensor</span> 
<span class="n">service</span> <span class="n">required</span> <span 
class="n">unavailable</span>
+</pre></div>
+
+
+<p>The flags can be used in conjunction with the other command options.</p>
+<p><strong>Find all components for a given classname</strong></p>
+<p><code>dm c .*ProbeImpl</code></p>
+<p><code>dm c</code> or <code>components</code> finds all components for which 
the classname of the implementation matches the regular expression.</p>
+<p><strong>Find all services matching a service filter</strong></p>
+<p><code>dm s "(type=temperature)"</code></p>
+<p><code>dm s</code> allows finding components based on the service properties 
of their registered services in the service registry using a standard OSGi 
service filter.</p>
+<p><strong>Find out why components are not registered</strong></p>
+<p><code>dm wtf</code></p>
+<p>Sample output:</p>
+<div class="codehilite"><pre><span class="gh">2 missing dependencies 
found.</span>
+<span class="gh">-----------------------------</span>
+The following service(s) are missing: 
+ * dm.demo.Sensor is not found in the service registry
+</pre></div>
+
+
+<p><code>wtf</code> gives the root cause for components not being registered 
and therefore their services not being available. In a typical application 
components have dependencies on services implemented by components that have 
dependencies on services etcetera. This transitivity means that an entire chain 
of components could be unregistered due to a (few) root dependencies not being 
satisfied. <code>wtf</code> is about discovering those dependencies.</p>
+      <div class="timestamp" style="margin-top: 30px; font-size: 80%; 
text-align: right;">
+        Rev. 1664113 by marrs on Wed, 4 Mar 2015 18:52:20 +0000
+      </div>
+      <div class="trademarkFooter"> 
+        Apache Felix, Felix, Apache, the Apache feather logo, and the Apache 
Felix project
+        logo are trademarks of The Apache Software Foundation. All other marks 
mentioned
+        may be trademarks or registered trademarks of their respective owners.
+      </div>
+    </div>
+  </body>
+</html>

Added: 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/tutorials/working-with-annotations.html
==============================================================================
--- 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/tutorials/working-with-annotations.html
 (added)
+++ 
websites/staging/felix/trunk/content/documentation/subprojects/apache-felix-dependency-manager/tutorials/working-with-annotations.html
 Tue Mar 10 21:03:25 2015
@@ -0,0 +1,287 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
"http://www.w3.org/TR/html4/loose.dtd";>
+<html>
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You under the Apache License, Version 2.0
+    (the "License"); you may not use this file except in compliance with
+    the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE- 2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+  <head>
+    <title>Apache Felix - Apache Felix Dependency Manager - Annotations</title>
+    <link rel="icon" href="/res/favicon.ico">
+    <link rel="stylesheet" href="/res/site.css" type="text/css" media="all">
+    <link rel="stylesheet" href="/res/codehilite.css" type="text/css" 
media="all">
+    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+  </head>
+  <body>
+    <div class="title">
+      <div class="logo">
+        <a href="http://felix.apache.org/";>
+          <img border="0" alt="Apache Felix" src="/res/logo.png">
+        </a>
+      </div>
+      <div class="header">
+        <a href="http://www.apache.org/";>
+          <img border="0" alt="Apache" src="/res/apache.png">
+        </a>
+      </div>
+    </div>
+    
+    <div class="menu"> 
+      <p><a href="/news.html">news</a>  <br />
+<a href="/license.html">license</a>  <br />
+<a href="/downloads.cgi">downloads</a>  <br />
+<a href="/documentation.html">documentation</a>  <br />
+<a href="/mailinglists.html">mailing lists</a>  <br />
+<a href="/documentation/community/contributing.html">contributing</a>  <br />
+<a href="/sitemap.html">site map</a>  <br />
+<a href="http://www.apache.org/";>asf</a>  <br />
+<a href="http://www.apache.org/security/";>security</a>  <br />
+<a href="http://www.apache.org/foundation/sponsorship.html";>sponsorship</a>  
<br />
+<a href="http://www.apache.org/foundation/thanks.html";>sponsors</a>    </p>
+<iframe
+    src="http://www.apache.org/ads/button.html";
+    style="border-width:0; float: left"
+    frameborder="0"
+    scrolling="no"
+    width="135"
+    height="135">
+</iframe>
+    </div>
+    
+    <div class="main">
+      <div class="breadcrump" style="font-size: 80%;">
+        <a href="/">Home</a>&nbsp;&raquo&nbsp;<a 
href="/documentation.html">Documentation</a>&nbsp;&raquo&nbsp;<a 
href="/documentation/subprojects.html">Apache Felix Subproject 
Documentation</a>&nbsp;&raquo&nbsp;<a 
href="/documentation/subprojects/apache-felix-dependency-manager.html">Apache 
Felix Dependency Manager 4</a>
+      </div>
+
+      
+      
+      <h1>Apache Felix Dependency Manager - Annotations</h1>
+      <p>The Dependency Manager provides a compact and versatile Java API that 
allows you to declaratively and programmatically register, acquire, and manage 
dynamic OSGi components. This has many advantages, but also means you need to 
implement your own <code>BundleActivator</code>. In cases where your 
dependencies are not that dynamic, an alternative is to use annotations on your 
component.</p>
+<p>This tutorial outlines how to setup and use such annotations to describe 
your components and dependencies. We present a simple "Hello World" component 
defined using annotations, and also explain how to build the bundle using 
either Bnd, Ant, or Maven.</p>
+<h2 id="hello-world-component">Hello World Component</h2>
+<div class="codehilite"><pre><span class="n">package</span> <span 
class="n">org</span><span class="p">.</span><span class="n">apache</span><span 
class="p">.</span><span class="n">felix</span><span class="p">.</span><span 
class="n">dependencymanager</span><span class="p">.</span><span 
class="n">samples</span><span class="p">.</span><span 
class="n">annotation</span><span class="p">.</span><span 
class="n">hello</span><span class="p">;</span>
+
+<span class="n">import</span> <span class="n">org</span><span 
class="p">.</span><span class="n">apache</span><span class="p">.</span><span 
class="n">felix</span><span class="p">.</span><span class="n">dm</span><span 
class="p">.</span><span class="n">annotation</span><span 
class="p">.</span><span class="n">api</span><span class="p">.</span><span 
class="n">Component</span><span class="p">;</span>
+<span class="n">import</span> <span class="n">org</span><span 
class="p">.</span><span class="n">apache</span><span class="p">.</span><span 
class="n">felix</span><span class="p">.</span><span class="n">dm</span><span 
class="p">.</span><span class="n">annotation</span><span 
class="p">.</span><span class="n">api</span><span class="p">.</span><span 
class="n">Start</span><span class="p">;</span>
+
+<span class="p">@</span><span class="n">Component</span>
+<span class="n">public</span> <span class="n">class</span> <span 
class="n">HelloWorld</span> <span class="p">{</span>
+    <span class="p">@</span><span class="n">Start</span>
+    <span class="n">public</span> <span class="n">void</span> <span 
class="n">activate</span><span class="p">()</span> <span class="p">{</span>
+       <span class="n">System</span><span class="p">.</span><span 
class="n">out</span><span class="p">.</span><span class="n">println</span><span 
class="p">(</span>&quot;<span class="n">Hello</span> <span 
class="n">world</span> !&quot;<span class="p">);</span>
+    <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<h2 id="compiling-with-bndtools">Compiling with BndTools:</h2>
+<p>This section is a step-by-step tutorial showing how to create a "greeting" 
project under BndTools and how to use Dependency Manager annotations.
+BndTools is a nice Eclipse plugin on top of the popular "Bnd" builder tool (<a 
href="http://bndtools.org/";>See The BndTools home page</a>).</p>
+<p>It is assumed that you have installed bndtools with a properly configured 
cnf project (using Bundle-Hub configuration).</p>
+<h3 id="add-dm-annotationjar-to-the-build-repository-and-to-the-buildpath">Add 
DM annotation.jar to the build repository and to the buildpath</h3>
+<p>Before creating a project that uses the DM annotations, you first have to 
add the DM annotation jar in the "cnd/buildrepo".
+(In the future, we'll push the DM annotation.jar to the Felix OBR, so you will 
then simply only have to create
+a bndtools remote repository that will point to the remote Felix OBR).</p>
+<ul>
+<li>Select the "Repositories" Window</li>
+<li>Select the "Build" repository</li>
+<li>Then click on the "Add Bundles to Repository" -&gt; "Add External Jar" and 
point the org.apache.felix.dependencymanager.anntation.jar.</li>
+<li>Then click on "Finish" button</li>
+</ul>
+<p>Now, declare the DM annotation plugin in the BndTools plugin path:</p>
+<ul>
+<li>Select "BndTools/Open ext/pluginpaths.bnd</li>
+<li>Select the "+" button of the "Plugin Path" section, and select 
"buildrepo/org.apache.felix.dependencymanager.annotation/org.apache.felix.dependencymanager.annotation-X.Y.Z.jar
 (replace X.Y.Z by the actual version)</li>
+<li>Then press "Ctrl-s" to save the configuration</li>
+</ul>
+<h3 id="create-the-greeting-project">Create the greeting project</h3>
+<p>Now we have properly configured the DM annotation plugin in bndtools, we 
can then create our "greeting" project.</p>
+<ul>
+<li>From the File menu, select "New -&gt; Bndtools OSGi Project" for creating 
an empty project, and call it "greeting".</li>
+<li>Click on bnd.bnd file of the greeting project, and click on the "Build" 
tab, then click on the "+" button, near the "Build Path" section.</li>
+<li>Then select "Build/org.apache.felix.dependencymanager.annotation" bundle 
and click on "Add --&gt;".</li>
+<li>Click on Finish, and save the project (press Ctrl-s).</li>
+</ul>
+<h3 id="creating-the-helloworld-component">Creating the HelloWorld 
component</h3>
+<p>Since we have configured the buildpath, we are now ready to create our 
first HelloWorld component using annotations.
+Create the following class in the greeting project:</p>
+<div class="codehilite"><pre><span class="kn">package</span> <span 
class="n">greeting</span><span class="o">;</span>
+
+<span class="kn">import</span> <span 
class="nn">org.apache.felix.dm.annotation.api.Component</span><span 
class="o">;</span>
+<span class="kn">import</span> <span 
class="nn">org.apache.felix.dm.annotation.api.Start</span><span 
class="o">;</span>
+
+<span class="nd">@Component</span>
+<span class="kd">public</span> <span class="kd">class</span> <span 
class="nc">HelloWorld</span> <span class="o">{</span>
+    <span class="nd">@Start</span>
+    <span class="kt">void</span> <span class="nf">start</span><span 
class="o">()</span> <span class="o">{</span>
+        <span class="n">System</span><span class="o">.</span><span 
class="na">out</span><span class="o">.</span><span 
class="na">println</span><span class="o">(</span><span class="s">&quot;Hello 
World&quot;</span><span class="o">);</span>
+    <span class="o">}</span>
+<span class="o">}</span>
+</pre></div>
+
+
+<h3 id="finalize-the-bnd-configuration">Finalize the bnd configuration</h3>
+<p>We have created our first HelloWorld component. We now have to finish the 
bnd configuration by specifying a Private-Package directive,
+and we also add the -plugin bnd directive in order to ask bnd to call the DM 
annotation plugin during compilation:</p>
+<ul>
+<li>Click on the bnd.bnd file of the greeting project</li>
+<li>Click on Contents and add the "greeting" package in the Private 
Packages</li>
+<li>Finally, declare the DM annotation plugin by clicking on the "source" tab, 
and add the following:<ul>
+<li>-plugin 
org.apache.felix.dm.annotation.plugin.bnd.AnnotationPlugin;log=debug</li>
+</ul>
+</li>
+<li>Save configuration (Press Ctrl-s)</li>
+<li>Click on "Build" and on "Rebuild"</li>
+</ul>
+<p>The greeting.jar should now be generated with a META-INF/dependencymanager/ 
directory. The plugin logs debug messages in /tmp/dmplugin/*</p>
+<p>So, the final bnd.bnd file should look like this:</p>
+<div class="codehilite"><pre>Bundle-Version: 0.0.0.<span 
class="cp">${</span><span class="n">tstamp</span><span class="cp">}</span>
+-buildpath: org.apache.felix.dependencymanager.annotation
+Private-Package: greeting
+-plugin org.apache.felix.dm.annotation.plugin.bnd.AnnotationPlugin;log=debug
+</pre></div>
+
+
+<h3 id="testing-the-bundle-under-bndtools">Testing the bundle under 
bndtools:</h3>
+<p>We are now going to execute a Felix framework under Eclipse/BndTools, and 
run our HelloWorld example.</p>
+<p>First, install the following necessary bundles in the "Local" repository:
+(in the future, we'll release the DM bundles in the Felix OBR, so you will 
only have to declare a remote repository, instead of doing this): </p>
+<ul>
+<li>Click on Repositories</li>
+<li>Add the following DM bundles in the "Local" Repository:<ul>
+<li>org.apache.felix.dependencymanager.jar</li>
+<li>org.apache.felix.dependencymanager.shell.jar</li>
+<li>org.apache.felix.dependencymanager.runtime.jar</li>
+</ul>
+</li>
+</ul>
+<p>Now, configure the Felix framework, as well as the list of the bundles to 
be executed:</p>
+<ul>
+<li>Click on the bnd.bnd file of the greeting project</li>
+<li>Click on the "Run" tab</li>
+<li>In the Core Runtime, Select the latest version of Felix currently 
available</li>
+<li>Select Execution Env=JavaSE-1.7</li>
+<li>In the "Run Bundles" section, add the following list:<ul>
+<li>org.apache.felix.configadmin.jar</li>
+<li>org.apache.felix.metatype.jar</li>
+<li>org.apache.felix.log.jar</li>
+<li>org.apache.felix.gogo.command</li>
+<li>org.apache.felix.gogo.runtime</li>
+<li>org.apache.felix.gogo.shell</li>
+<li>org.apache.felix.dependencymanager</li>
+<li>org.apache.felix.dependencymanager.runtime</li>
+<li>org.apache.felix.dependencymanager.shell</li>
+</ul>
+</li>
+<li>Then save the configuration (Press Ctrl-s).</li>
+</ul>
+<p>Now, Click on "Run OSGi". You should now see in the Console the Gogo Shell 
prompt with the
+message displayed by the HelloWorld component:</p>
+<div class="codehilite"><pre><span class="n">Hello</span> <span 
class="n">World</span>
+<span class="n">Welcome</span> <span class="n">to</span> <span 
class="n">Apache</span> <span class="n">Felix</span> <span class="n">Gogo</span>
+<span class="n">g</span>!
+</pre></div>
+
+
+<p>Just type "dm" in the console, and you should see:</p>
+<div class="codehilite"><pre><span class="p">[</span>2<span class="p">]</span> 
<span class="n">org</span><span class="p">.</span><span 
class="n">apache</span><span class="p">.</span><span 
class="n">felix</span><span class="p">.</span><span 
class="n">dependencymanager</span><span class="p">.</span><span 
class="n">runtime</span>
+ <span class="p">[</span>0<span class="p">]</span> <span 
class="n">org</span><span class="p">.</span><span class="n">apache</span><span 
class="p">.</span><span class="n">felix</span><span class="p">.</span><span 
class="n">dm</span><span class="p">.</span><span class="n">runtime</span><span 
class="p">.</span><span class="n">DependencyManagerRuntime</span> <span 
class="n">registered</span>
+    <span class="n">active</span> <span class="p">(</span><span 
class="n">DependencyManager</span><span class="o">-</span><span 
class="n">Component</span><span class="p">=</span><span class="o">*</span><span 
class="p">)</span> <span class="n">bundle</span> <span 
class="n">optional</span> <span class="n">available</span>
+    <span class="n">org</span><span class="p">.</span><span 
class="n">osgi</span><span class="p">.</span><span 
class="n">service</span><span class="p">.</span><span 
class="n">packageadmin</span><span class="p">.</span><span 
class="n">PackageAdmin</span> <span class="n">service</span> <span 
class="n">required</span> <span class="n">available</span>
+    <span class="n">org</span><span class="p">.</span><span 
class="n">osgi</span><span class="p">.</span><span 
class="n">service</span><span class="p">.</span><span 
class="nb">log</span><span class="p">.</span><span class="n">LogService</span> 
<span class="n">service</span> <span class="n">optional</span> <span 
class="n">available</span>
+<span class="p">[</span>10<span class="p">]</span> <span 
class="n">greeting</span>
+ <span class="p">[</span>1<span class="p">]</span> <span 
class="n">greeting</span><span class="p">.</span><span 
class="n">HelloWorld</span> <span class="n">registered</span>
+</pre></div>
+
+
+<p>The bundle [2] is the dependency manager runtime bundle that is in charge 
of managing all bundles containing annotated components.
+And the bundle [10] is our greeting bundle (and the "greeting.HelloWorld" 
component is registered).</p>
+<h2 id="compiling-with-ant">Compiling with Ant:</h2>
+<p>Since Bnd provides a Ant task, you can use the bnd directives above with 
the following build.xml:
+(it is assumed that directives.bnd, bnd.jar, json-20070829.jar and 
org.apache.felix.dependencymanager.annotation.jar are in the current 
directory)</p>
+<div class="codehilite"><pre><span class="nt">&lt;project</span> <span 
class="na">name=</span><span class="s">&quot;TestDM&quot;</span> <span 
class="na">default=</span><span class="s">&quot;bnd&quot;</span><span 
class="nt">&gt;</span>
+    <span class="nt">&lt;property</span> <span class="na">name=</span><span 
class="s">&quot;bnd&quot;</span> <span class="na">value=</span><span 
class="s">&quot;bnd.jar&quot;</span> <span class="nt">/&gt;</span>
+    <span class="nt">&lt;property</span> <span class="na">name=</span><span 
class="s">&quot;json&quot;</span> <span class="na">value=</span><span 
class="s">&quot;json-20070829.jar&quot;</span> <span class="nt">/&gt;</span>
+    <span class="nt">&lt;property</span> <span class="na">name=</span><span 
class="s">&quot;dmannot&quot;</span> <span class="na">value=</span><span 
class="s">&quot;org.apache.felix.dependencymanager.annotation.jar&quot;</span> 
<span class="nt">/&gt;</span>
+
+    <span class="nt">&lt;target</span> <span class="na">name=</span><span 
class="s">&quot;compile&quot;</span><span class="nt">&gt;</span>
+        <span class="nt">&lt;delete</span> <span class="na">dir=</span><span 
class="s">&quot;target/classes&quot;</span> <span class="na">quiet=</span><span 
class="s">&quot;yes&quot;</span> <span class="nt">/&gt;</span>
+        <span class="nt">&lt;mkdir</span> <span class="na">dir=</span><span 
class="s">&quot;target/classes&quot;</span> <span class="nt">/&gt;</span>
+        <span class="nt">&lt;javac</span> <span class="na">srcdir=</span><span 
class="s">&quot;src/main/java&quot;</span> <span 
class="na">destdir=</span><span class="s">&quot;target/classes&quot;</span> 
<span class="na">classpath=</span><span class="s">&quot;</span><span 
class="cp">${</span><span class="n">dmannot</span><span 
class="cp">}</span><span class="s">&quot;</span> <span class="nt">/&gt;</span>
+    <span class="nt">&lt;/target&gt;</span>
+
+    <span class="nt">&lt;target</span> <span class="na">name=</span><span 
class="s">&quot;bnd&quot;</span> <span class="na">depends=</span><span 
class="s">&quot;compile&quot;</span><span class="nt">&gt;</span>
+        <span class="nt">&lt;taskdef</span> <span 
class="na">resource=</span><span 
class="s">&quot;aQute/bnd/ant/taskdef.properties&quot;</span> <span 
class="na">classpath=</span><span class="s">&quot;</span><span 
class="cp">${</span><span class="n">dmannot</span><span 
class="cp">}</span><span class="s">:</span><span class="cp">${</span><span 
class="n">bnd</span><span class="cp">}</span><span class="s">:</span><span 
class="cp">${</span><span class="n">json</span><span class="cp">}</span><span 
class="s">&quot;</span> <span class="nt">/&gt;</span>
+        <span class="nt">&lt;bnd</span> <span 
class="na">classpath=</span><span class="s">&quot;target/classes&quot;</span> 
<span class="na">eclipse=</span><span class="s">&quot;false&quot;</span> <span 
class="na">files=</span><span class="s">&quot;directives.bnd&quot;</span> <span 
class="na">output=</span><span 
class="s">&quot;org.apache.felix.dependencymanager.samples.annotation.hello.jar&quot;</span>
 <span class="nt">/&gt;</span>
+    <span class="nt">&lt;/target&gt;</span>
+<span class="nt">&lt;/project&gt;</span>
+</pre></div>
+
+
+<h2 id="compiling-with-maven">Compiling with Maven:</h2>
+<p>When compiling with Maven, you have to invoke the Dependency Manager Bnd 
plugin, using the special "_plugin" directive.
+In the R1 Dependency Manager distribution, the bundles are not published to 
maven central, and you
+have to manually install the org.apache.felix.dependencymanager.annotation.jar 
file to your local repository, or to your own corporate nexus server.
+(<a 
href="http://maven.apache.org/guides/mini/guide-3rd-party-jars-local.html";>See 
this link</a> to manually install the dm annotation jar to your local 
repository.)</p>
+<div class="codehilite"><pre><span class="nt">&lt;project</span> <span 
class="err">...</span><span class="nt">&gt;</span>
+  <span class="nt">&lt;dependencies&gt;</span>
+    ...
+    <span class="nt">&lt;dependency&gt;</span>
+      <span class="nt">&lt;groupId&gt;</span>org.apache.felix<span 
class="nt">&lt;/groupId&gt;</span>
+      <span 
class="nt">&lt;artifactId&gt;</span>org.apache.felix.dependencymanager.annotation<span
 class="nt">&lt;/artifactId&gt;</span>
+      <span class="nt">&lt;version&gt;</span>4.0.0<span 
class="nt">&lt;/version&gt;</span>
+    <span class="nt">&lt;/dependency&gt;</span>
+  <span class="nt">&lt;/dependencies&gt;</span>
+  <span class="nt">&lt;build&gt;</span>
+    <span class="nt">&lt;plugins&gt;</span>
+      ...    
+      <span class="nt">&lt;plugin&gt;</span>
+        <span class="nt">&lt;groupId&gt;</span>org.apache.felix<span 
class="nt">&lt;/groupId&gt;</span>
+        <span class="nt">&lt;artifactId&gt;</span>maven-bundle-plugin<span 
class="nt">&lt;/artifactId&gt;</span>
+        <span class="nt">&lt;version&gt;</span>2.5.0<span 
class="nt">&lt;/version&gt;</span>
+        <span class="nt">&lt;extensions&gt;</span>true<span 
class="nt">&lt;/extensions&gt;</span>
+        <span class="nt">&lt;configuration&gt;</span>
+           <span class="nt">&lt;instructions&gt;</span>
+           <span class="nt">&lt;Bundle-Name&gt;</span>Test<span 
class="nt">&lt;/Bundle-Name&gt;</span>
+           <span class="nt">&lt;Bundle-SymbolicName&gt;</span>test<span 
class="nt">&lt;/Bundle-SymbolicName&gt;</span>
+           <span class="nt">&lt;Import-Package&gt;</span>*<span 
class="nt">&lt;/Import-Package&gt;</span>
+           <span 
class="nt">&lt;Private-Package&gt;</span>test.dmannotations<span 
class="nt">&lt;/Private-Package&gt;</span>
+           <span class="c">&lt;!-- when setting log=debug, logs are writen to 
/tmp/dmplugin/ directory --&gt;</span>
+           <span 
class="nt">&lt;_plugin&gt;</span>org.apache.felix.dm.annotation.plugin.bnd.AnnotationPlugin;log=debug<span
 class="nt">&lt;/_plugin&gt;</span>
+           <span class="nt">&lt;/instructions&gt;</span>
+        <span class="nt">&lt;/configuration&gt;</span>
+        <span class="nt">&lt;dependencies&gt;</span>
+          <span class="nt">&lt;dependency&gt;</span>
+            <span class="nt">&lt;groupId&gt;</span>org.apache.felix<span 
class="nt">&lt;/groupId&gt;</span>
+            <span 
class="nt">&lt;artifactId&gt;</span>org.apache.felix.dependencymanager.annotation<span
 class="nt">&lt;/artifactId&gt;</span>
+            <span class="nt">&lt;version&gt;</span>4.0.0<span 
class="nt">&lt;/version&gt;</span>
+          <span class="nt">&lt;/dependency&gt;</span>
+        <span class="nt">&lt;/dependencies&gt;</span>
+      <span class="nt">&lt;/plugin&gt;</span>
+    <span class="nt">&lt;/plugins&gt;</span>
+  <span class="nt">&lt;/build&gt;</span>
+<span class="nt">&lt;/project&gt;</span>
+</pre></div>
+      <div class="timestamp" style="margin-top: 30px; font-size: 80%; 
text-align: right;">
+        Rev. 1664920 by pderop on Sat, 7 Mar 2015 21:22:46 +0000
+      </div>
+      <div class="trademarkFooter"> 
+        Apache Felix, Felix, Apache, the Apache feather logo, and the Apache 
Felix project
+        logo are trademarks of The Apache Software Foundation. All other marks 
mentioned
+        may be trademarks or registered trademarks of their respective owners.
+      </div>
+    </div>
+  </body>
+</html>

Modified: websites/staging/felix/trunk/content/index.html
==============================================================================
--- websites/staging/felix/trunk/content/index.html (original)
+++ websites/staging/felix/trunk/content/index.html Tue Mar 10 21:03:25 2015
@@ -92,7 +92,7 @@ The original Confluence based site is cu
 <p>The Felix project is organized into subprojects, where each subproject 
targets a specific OSGi specification or OSGi-related technology; the following 
list summarizes each released subproject:</p>
 <ul>
 <li><a href="/documentation/subprojects/apache-felix-config-admin.html">Config 
Admin</a> - An implementation of the OSGi Configuration Admin service 
specification for managing bundle configuration properties.</li>
-<li><a href="">Dependency Manager</a> - An API-based component model to 
simplify OSGi-based development.</li>
+<li><a 
href="/documentation/subprojects/apache-felix-dependency-manager.html">Dependency
 Manager</a> - An API-based component model to simplify OSGi-based 
development.</li>
 <li><a href="/documentation/subprojects/apache-felix-event-admin.html">Event 
Admin</a> - An implementation of the OSGi Event Admin service specification for 
event-based communication.</li>
 <li><a href="/documentation/subprojects/apache-felix-file-install.html">File 
Install</a> - A simple, directory-based management agent for managing bundle 
deployment.</li>
 <li><a 
href="/documentation/subprojects/apache-felix-framework.html">Framework</a> - 
An implementation of the OSGi R5 core framework.</li>


Reply via email to