Store Tutorial
==============

This tutorial that shows how to use SCA and Tuscany to build multiple
variations of an online Store application. The variations demostrate the
evolution of the Store as it goes through the following stages:

1 - Initial online fruit store
2 - Fruit store merges with vegetable store to form the fruit and vegetable store
3 - The fruit and vegetable store move to using a database for storing the cart
4 - The fruit and vegetable store acts as a supplier to other online stores
5 - The fruit and vegetable store ships their software solution to another geography
6 - The fruit and vegetable running in the enterprise

For diagrams of the scenarios covered here, please refer to Tutorial.pdf

Running The Tutorial Application
--------------------------------

Start the SCA Domain Manager on linux:

   cd domain
   java -jar ../../../modules/tuscany-node-launcher-1.5.jar domain

Start the SCA Domain Manager on windows:

   cd domain
   java -jar ..\..\..\modules\tuscany-node-launcher-1.5.jar domain

Access the SCA Domain Manager application by pointing your Web browser at:

   http://localhost:9990/ui/cloud/

This shows you all of the Tuscany nodes that are configured to run 
in the store tutorial domain. If you are interested, the configuration
is stored on disc in the store/domain directory but for now let's just 
start some nodes and see what happens. 

The different nodes you see are used to start different scenarios in 
the tutorial. Select the node you want to start (e.g StoreNode), then click the 
Start button. You may need to give the nodes a little time to start up. Check the
console where you lauched the domain manager application and you will see the 
following message when nodes have started.

INFO: INFO: Press 'q' to quit, 'r' to restart.

Remember to shut down the nodes before you exit the domain manager application. 

The following describes the nodes you have to start for each scenario and some
usful links to explore once the node has started. 

1 - Initial online fruit store
----------------------------

Start 

   StoreNode 

The store itself can be found at 
     
   http://localhost:8100/ui/ 

If you want to look at how Tuscany provides remote bindings you can take
a look at the service description that Tuscany created automatically
for the store catalog service which is exposed over a JSONRPC binding 
Point your browser at:
  
    http://l3localhost:8100/StoreCatalog?smd
  
The service is configured in the SCA composite file in the following way:

	<component name="StoreCatalog">
		<implementation.java class="services.FruitsCatalogImpl"/> 
		<property name="currencyCode">USD</property>
		<service name="Catalog">
			<t:binding.jsonrpc/>
   		</service>
		<reference name="currencyConverter" target="StoreCurrencyConverter"/>	
	</component>   

Note the inclusion of <t:binding.jsonrpc/>. This is all that is required to 
make this service available over JSONRPC. If you want to expose the service
over web services simply add <binding.ws/> instead of (or as well as) <t:binding.jsonrpc/>. 

2 - Fruit store merges with vegetable store to form the fruit and vegetable store
---------------------------------------------------------------------------------

Start 

   CatalogsNode
   StoreMergerNode 

The store itself can be found at 
     
   http://localhost:8101/ui/

Now you see that there are more items in the catalog as the fruit and 
vegetable catalogs are both providing content. The vegetable catalog
that was introduced during the merger is contacted using web services.
If you want to see the WSDL for the vegetable catalog point your browser
at

http://l3aw203:8200/VegetablesCatalogWebService?wsdl

The vegetable catalog service is configured in an SCA composite file
in the following way:

	<component name="VegetablesCatalogWebService">
		<implementation.java class="services.VegetablesCatalogImpl"/>
		<service name="Catalog">
			<binding.ws/>
		</service> 
	</component>

3 - The fruit and vegetable store move to using a database to storing the cart
------------------------------------------------------------------------------

Start
   
   StoreDBNode 

The store itself can be found at 

   http://l3aw203:8102/ui/

This looks the same as the scenario 2 store but this time a database is used
for storing items put into the shopping cart. When you add items you 
will see messages on the console indicating that items are added to the
database. For example. 

INFO: insert into Cart values ('cart-8c8bcc43-5036-4e9a-b282-0dd3d00d350c', 'Apple', '$2.99')

This scenario shows how you change the implementation of a service without 
changing any of the configuration of the rest of the application

4 - The fruit and vegetable store acts as a supplier to other online stores
---------------------------------------------------------------------------

Start 

   StoreSupplierNode

The store itself can be found at 

   http://localhost:8103/ui/
  
Again this is the same basic store as in scenario 3. However this time the 
shopping cart and catalog serivces have been given additional remote bindings so that
the services can be accessed by others. For example, take a look at the WSDL
description of the shopping cart service that is now available at:

   http://l3aw203:8333/ShoppinCartTotalWebService?wsdl

This WSDL is available as the shopping cart total service is now configured with a web services
binding in the following way:

 	<component name="StoreSupplierShoppingCart">
		<implementation.java class="services.db.ShoppingCartTableImpl"/>
		<property name="database">../store-supplier/target/cart-db</property>
		<service name="Cart">
			<t:binding.atom uri="/ShoppingCart/Cart"/>
		</service>    	
		<service name="Total">
			<t:binding.jsonrpc/>
			<binding.ws uri="/ShoppinCartTotalWebService"/>
		</service>
	</component>

If you want to actually exercise these services from a standalone application
you can run up the StoreClientNode using the provided launcher

store/store-client/launch/LaunchStoreClientNode


5 - The fruit and vegetable store ships their software solution to another geography
------------------------------------------------------------------------------------

Start
  
   CurrencyNode
   StoreEUNode

The store itself can be found at 

   http://localhost:8104/ui/

Notice now that the prices are quoted in Euros and the language is French. This was 
achieved by editing the store.html file to change the language and presentation to 
be appropriate for Europe. The curreny was changed by reconfiguring the catalog
component to use EUR instead of USD.

	<component name="StoreEUCatalog">
		<implementation.java class="services.merger.MergedCatalogImpl"/> 
		<property name="currencyCode">EUR</property>
                ...
        </component>

6 - The fruit and vegetable running in the enterprise
---------------------------------------------------------------------------------

Start 

   CatalogsNode
   StoreEnterpriseNode 

Separately run 
   LaunchWarehouseSpring from the command line
   TBD

The LaunchWarehouseSpring program starts the node for the warehouse based on local
configuration. It doesn't use the domain manager like the other nodes we start do. 
It also start and ActiveMQ broker via which JMS messages will pass. 

The store itself can be found at 
     
   http://localhost:8108/ui/

The items in the catalog as much the same as the previous examples. 
This time though when you place the order a message is sent over JMS to 
the warehouse component running outside the domain and listening on JMS. 
In this case we have implemented the warehouse application using SCA and it
has it's own UI. The UI can be found at

http://l3aw203:8088/ui/

You should see the orders accumulating. YOu can't do anything with the
orders but it is just a demo.

The warecouse component is configured in the  composite file
in the following way:

	<component name="Warehouse">
		<implementation.java class="services.WarehouseImpl"/> 
		<service name="Warehouse">
			<t:binding.jsonrpc uri="http://localhost:8088/Warehouse"/>
            <binding.jms initialContextFactory="org.apache.activemq.jndi.ActiveMQInitialContextFactory"
                         jndiURL="tcp://localhost:61619">
                <destination name="RequestQueue" create="ifnotexist"/>
                <response>
                    <destination name="ResponseQueue" create="ifnotexist"/>
                </response> 
            </binding.jms>
   		</service>
	</component> 

And the shopping cart component that talks to it is configured as follows

	<component name="StoreEnterpriseShoppingCart">
		<implementation.java class="services.ShoppingCartImpl"/>
		<service name="Cart">
			<t:binding.atom uri="/ShoppingCart/Cart"/>
		</service>    	
		<service name="Total">
			<t:binding.jsonrpc/>
		</service>
        <reference name="warehouse" multiplicity="0..1" >
            <binding.jms initialContextFactory="org.apache.activemq.jndi.ActiveMQInitialContextFactory"
                         jndiURL="tcp://localhost:61619">
                 <destination name="RequestQueue" create="always"/>
                 <response>
                     <destination name="ResponseQueue" create="always"/>
                 </response>
            </binding.jms>
        </reference>
	</component>


For more detailed information about how to get started with Apache Tuscany
see our online guides at:

http://tuscany.apache.org/sca-java-getting-started-guides-1x.html