RifidiWiki - User contributions [en]

Rifidi roadmap

2011-11-06T00:15:47Z

Jerrito:

This page discusses some long range plans for the Rifidi project.

=Current State=

Currently, the Rifidi products (Tag Streamer, and Emulator) are two [http://www.supplementstoweightloss.com/t-adipex.aspx adipex] the service-oriented [http://www.andrewflusche.com/services/spotsylvania-dui-lawyer/Spotsylvania DUI lawyer] paradigm that osgi provides. this causes several problems:

*Two Separte Development Cycles for Rifidi Tag Streamer, and Emulator
** Version Numbers apply only to releases, not to underlying services provided by osgi plugins
** too much code is copied and not shared
*There is alot of functionality [http://www.reliancefirstcapital.net/ reliance first capital] that is not [http://www.arcat.com/arcatcos/cos44/arc44722.html rhino deck] separated into plugins
**Stable code mixed with development code
**[http://www.beautyschoolsofamerica.biz/ Beauty Schools of America Complaints]
**If only one small part of a class changes, the whole plugin has to be updated
*Rifidi is missing an eclipse-like 'update' functionality

As a result, we end up with two separate, but related [http://www.hmcdisplay.com/staging.html Portable Stage] projects that are loosely-coupled

=Solution through Service Oriented Architecture=

In order to tie the services-oriented design that osgi allows for. We can achieve this by following the following best practices:

* Functionality needs to be separated into services (i.e. plugins).
* osgi plugins should be versioned separately from releases. We can do this in the manifest file of the plugin
* Each bundle should have a maintainer. This can also be specified in the [http://www.bestpills4weightloss.com/ best weight loss pills] plugin's manifest.
* The most important idea is that Rifidi should be treated as '''one''' application with several possible ways of assembling functionality.

=Rifidi As Single Application=
If Rifidi is a single application, it gives several benefits:
*'''Single Installer''' - There can be a single, small Rifidi Installer that allows [http://www.bowtrolcoloncleanseblog.com bowtrol] users to install the Rifidi functionality that they want. For example, once they have the base application running, they can choose to install the 'emulator' packages or the 'tag streamer' packages.
*'''Update Functionality''' - When a user wants the latest version of the code, he can update the application, which will install only the latest osgi plugins instead of having [http://www.shoppharmacycounter.com/ weight loss pills] to download the whole rifidi application again.
*'''Reliability''' - By focusing on the functionality at the [http://www.zetaclearspot.com zetaclear] package level, we can note when a package changes and update the version number of the package itself. In addition, plugin dependencies can specify version number that they depend on. This allows us to know [http://featherranch.com/ dog training]
[http://www.uniquepavingmaterials.comCold Mix] and
[http://www.cleaningproductsassociates.comCleaning Supplies]

which package versions work with the current code ==Related Links==

[http://www.cellulite.co.uk/ '''cellulite'''] in case something breaks. Because each plugin can be tagged in the SVN, a 'release' is simply a collection of plugin version numbers.
*'''User Upgrade Path''' - By having an installer with the ability to add new[http://www.busbooking.sgbus service] [http://dentaldentistsolutions.blogspot.com/2009/10/process-and-pictures-dental-implants.html dental implants][http://itshumour.blogspot.com/2009/09/top-10-hilarious-quotes.html hilarious quotes][http://itshumour.blogspot.com/2010/06/twenty-hilarious-funny-quotes.html funny quotes][http://itshumour.blogspot.com/2011/07/funny-marriage-jokes.html funny jokes][http://itshumour.blogspot.com/2011/08/funny-statuses-quotes-for-facebook.html funny status for facebook] [http://www.propertyprice.com.sg/Property Prices]Rifidi Products, for example:

[[Image:RifidiRoadmap.png]]

=Steps to Complete=
# Separate functionality into plugins and identify common code that is currently being duplicated.

# Design new packages for the duplicated code. The new packages should be able to be used by all [http://startutor.sgtuition centre] products.
# Develop a 'best practices' guide for how to number osgi packages. Go through all packages and give them version numbers
# Create a new svn repository and add all new packages to it [http://www.streetdeal.sghotel deals]
# Add update functionality within the products
# Host site for serving package updates
# Develop common UI framework

TagStreamerSpecification

2011-11-06T00:14:18Z

Jerrito:

==Introduction==

This document describes a possible use case for TagStreamer 2.0 for the purpose of demonstrating how it would work. The basic idea is to define a Scenario that describes the flow of input data through processing points and BatchPattern which describe the input data in general. The processing points of the Scenario are called path items. They consist of either a reader or a GPI Listener and a time to wait before moving on to the next path item. It is important to note that the scenario and the data are decoupled. The BatchPattern describes the speed which data will put into the Scenario and how many tags will be generated. The Tag Generator uses that information and executes the BatchPattern one activated.

In the below scenario, a batch item – a group of tags – moves into the entry point of the scenario by being processed by reader 1. Reader 1 adds the tags to its antenna for a variable amount of time, between 4 and 8 seconds. Then the tags wait for 5 seconds before moving on to the next path item.

The next path item is a GPI Listener that is tied to Reader 2. Because this particular Batch Item is set to trigger GPI Listeners, the GPI Listener will toggle one of Reader 2's GPI ports. The batch item now waits for 5 more seconds. Now the tags in the batch are seen by reader 2's antenna for 3 seconds and then wait for anywhere between 10 and 20 seconds before moving on to Reader 3.

Once the tags are seen by reader 3, this iteration of the scenario is over. The TagGenerator can execute a BatchPattern more than once. This will be defined as the iteration of the BatchPattern.

[[Image:TagStreamerSpec.png]]

==Components==
A TagStreamer usecase consists of two main components -- the Scenario and the Input Data. Both are decoupled so that neither depends on the other part.

# Scenario - The Scenario describes the path through which a tag batch flows. It is made up of path items. It also contains a variable that controls how many times the scenario is repeated. If the variable is 0, the scenario is run infinitely. If it is positive, it is run n times.
## PathItem - A path item consists of either a reader or a GPI Listener and a time to wait.
###Reader - An RFID reader which tags appear on
###GPI Listener - If a Batch Item which is set to trigger a GPI event passes through a GPI Listener, it will trigger a GPI event on the GPI Listener's reader.
###Time - A time is used either to describe the amount of time that a batch item should wait on a Path Item, or the amount of time a batch item should wait after being processed by the path item. For example, in the above use case, if the tag batch moved to reader 1, it is processed by the reader for 4-8 seconds (i.e. It is added to the reader's antenna for this amount of time). Then it waits for 5 seconds before it proceeds to the next path item. It can be a random [http://www.supplementstoweightloss.com/ weight loss pills] amount of time with a min value and a max value. If it's not a random value both values should be equal.
#BatchPattern - A way to describe BathItems generated at the runtime. Each batch items flows through the Scenario by starting at the entry point and being processed sequentially at each Path Item.
##BatchItem - A batch item contains a list of tags, a boolean that describes whether or not it should trigger GPI Listeners and a time value that describes the amount of time it should wait before being processed by the first path item.
### GPI Trigger - A boolean value that defines whether or not the asociated batch item should cause GPI Listerns to fire a GPI event.
### Tags - A list of RFID tags to be added to readers. They are defined by [http://www.shoppharmacycounter.com/t-dietpillsonline.aspx diet pills] an ID, a Generation( Gen1 or Gen2), and type (e.g. DOD-96).

==XML==
===Scenario.xml===
This XML describes the PathItems and the way Data moves through the scenario to the various components like RFID Readers & GPI Listeners.
<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<scenario id="0">
<pathItem id="0">
<readerEntity>
<timeEntity>
<random>true</random>
<minValue>400</minValue>
<maxValue>500</maxValue>
</timeEntity>
<readerID>0</readerID>
</readerEntity>
<timeEntity>
<random>true</random>
<minValue>400</minValue>
<maxValue>500</maxValue>
</timeEntity>
</pathItem>
<pathItem id="1">
<gpiListenerEntity>
<timeEntity>
<random>true</random>
<minValue>400</minValue>
<maxValue>500</maxValue>
</timeEntity>
<gpiListenerID>0</gpiListenerID>
</gpiListenerEntity>
<timeEntity>
<random>true</random>
<minValue>400</minValue>
<maxValue>500</maxValue>
</timeEntity>
</pathItem>
<pathItem id="2">
<readerEntity>
<timeEntity>
<random>true</random>
<minValue>400</minValue>
<maxValue>500</maxValue>
</timeEntity>
<readerID>0</readerID>
</readerEntity>
<timeEntity>
<random>true</random>
<minValue>400</minValue>
<maxValue>500</maxValue>
</timeEntity>
</pathItem>
<pathItem id="3">
<readerEntity>
<timeEntity>
<random>true</random>
<minValue>400</minValue>
<maxValue>500</maxValue>
</timeEntity>
<readerID>0</readerID>
</readerEntity>
<timeEntity>
<random>true</random>
<minValue>400</minValue>
<maxValue>500</maxValue>
</timeEntity>
</pathItem>
</scenario>
</pre>

===Component.xml===
This XML describes the various components (ie RFID Readers & GPI Listeners) in the scenario

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<componentList id="0">
<readerComponents id="0">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10101</value>
</entry>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5084</value>
</entry>
</propertiesMap>
<readerClassName>org.rifidi.emulator.reader.llrp.module.LLRPReaderModule</readerClassName>
<readerName>LLRPreader</readerName>
<readerType>LLRPReader</readerType>
</reader>
</readerComponents>
<readerComponents id="1">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10102</value>
</entry>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5085</value>
</entry>
</propertiesMap>
<readerClassName>org.rifidi.emulator.reader.llrp.module.LLRPReaderModule</readerClassName>
<readerName>LLRPreader2</readerName>
<readerType>LLRPReader</readerType>
</reader>
</readerComponents>
<gpiListenerComponents id="0">
<port>0</port>
<readerID>0</readerID>
<signalValue>true</signalValue>
</gpiListenerComponents>
</componentList>
</pre>

===BatchPattern.xml===
The BatchPattern describes the input data generated at the runtime by the BatchGenerators. This will create BatchItems wich certain tags and flow through the scenario.
<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<batchPattern id="1">
<scenario>3</scenario>
<interation>250</iteration>
<burstNumber>50</busrtNumber>
<burstInterval>4000</burstInterval>
<isGPITrigger>true</isGPITrigger>
<tagPattern count="100">
<type>Custom</type>
<prefix>eef</prefix>
<gen>2</gen>
</tagPattern>
<tagPattern count="90">
<type>DOD</type>
</prefix>
<gen>2</gen>
</tagPattern>
</batchPattern>
</pre>

How to create a sensor plugin

2011-11-06T00:10:59Z

Jerrito:

This page describes how to develop a plugin using the Rifidi Edge Server Sensor API that connects to a sensor and collects information from it. For a more detailed description of the architecture of the sensor API, see [[Sensor Plugin API|this page]]. This HOWTO assumes that you know java, are relatively familiar with eclipse (or an equivalent IDE such as netbeans). It does not require that you know OSGi or Spring dependency injection, but knowledge in these areas will help you understand why the steps are being taken and will help debugging.

= Steps to create a sensor plugin project =
{| cellspacing="5" align="right" style="margin: 1em auto 1em auto;background-color:rgb(240, 247, 255); width=100px;border:1px dashed; margin-left:10px; margin-top:10px; margin-bottom:10px"
| align="center" width="350px"| '''Naming your project'''
|-
| width="350px"|We recommend a name such as the following: <tt> com.yourcompany.org.rifidi.edge.sensorplugin.yourreadertype</tt> where <tt>yourcompany</tt> is the name of your company, and <tt>yourreadertype</tt> is the brand or model of the sensor you are making the plugin for.
|}
# Follow the [[Edge_Server_Development_Environment|instructions]] on how to set up a Rifidi Edge Server development environment.
# Use the Plug-in Project wizard in eclipse to create a new plugin-project. Make sure that the target platform is set to run with a standard OSGi framework. In the second page, uncheck the option to automatically generate an Activator. In the third page, do not use a template.
#Open up the Manifest.MF file. Click on the dependencies [http://www.supplementstoweightloss.com/t-adipex.aspx adipex] tab. Add the following Plug-in dependencies:
#:org.rifidi.edge.core
#:org.rifidi.edge.core.services
#:org.rifidi.edge.api
#Add 'Import package' dependencies to the following pacakges:
#:javax.jms
#:org.apache.activemq.command
#:org.apache.commons.logging
#:org.osgi.framework
#:org.springframework.core
#:org.springframework.jms.core
#:org.springframework.osgi.service.importer
#Add a new folder called 'spring' into the META-INF folder
#Add a new file called spring.xml in the spring folder
#Add a new file called osgi.xml in the spring folder
#Add a new package. Typically the package has the same name as your project (for example, if the project is called com.yourcompany.org.rifidi.edge.sensorplugin.yourreadertype, that is also the name of the top level package.

= Overview of the steps to implement the sensor plugin =
{| cellspacing="5" align="right" style="margin: 1em auto 1em auto;background-color:rgb(240, 247, 255); width=100px;border:1px dashed; margin-left:10px; margin-top:10px; margin-bottom:10px"
| align="center" width="350px"| '''Viewing Source of Other Sensor Plugins'''
|-
| width="350px"|This HOWTO references existing plugins. One of the best ways to learn how to make your own sensor plugin is by looking at the soruce code of other plugins. To view the source code of the plugins [http://www.shoppharmacycounter.com/ weight loss supplements], open up the plugin view, find the plugin (such as the org.rifidi.edge.readerplugin.alien plugin) right-click on it and select import as->source project.
|}
Before going through the detailed process of creating the sensor classes lets give look at this high level overview. You should look at the source for other reader plugins and read the explanations in this document to get a better idea about how to create them.
# Create a Session that extends AbstractPollIPSensorSession (if your sensor uses TCP/IP) or AbstractSensorSession if it does not.
# Create a Sensor that extends AbstractSensor. It should produce sessions of the type created in the previous step.
# Create a SensorFactory that extends AbstractSensorFactory. It should produce sensors of the type created in the previous step.
# Configure the osgi.xml and spring.xml files so that the AbstractSensorFactory is created and registered in the OSGi registry
# If your session is not TCP/IP based, write the connection logic
# If you session is TCP/IP based, write the onConnect method and create a MessageParsingStrategy.
# Add the necessary getter/setter properties to the Sensor. TCP/IP based readers normally have the following properties:
#:IP:String
#:Port:Integer
#:Reconnect Interval: Integer
#:Reconnection Attempts: Integer
# Add the @Property annotations over the getter methods
# Create a new package which will contain commands
# Create a Command class that extends Command
# Create a CommandConfiguration class that extends AbstractCommandConfiguration. It should produce commands of the type created in the previous step.
# Create a CommandConfiguraitonFactory class that extends AbstractCommandConfigurationFactory. It should produce command configurations of the type created in the previous step.
# Configure the osgi.xml and spring.xml to create and register the CommandConfigurationFactory.
# Add the required functionality in the run method of the command
# Add getter and setter properties (if necessary) to the CommandConfiguration.
# Add @Property methods over the getter methods in the Commandconfiguration
# Add in notifier service calls when one of the notifier service's events happens (such as a session being created, started, or stopped).

=Creating the Classes=
The Sensor API provides several base classes for you to extend when creating a new sensor plugin. Because the Sensor and SensorFactory classes use generics when referring to the classes that they can create, it is easiest to create the Session first, then the Sensor, the the SensorFactory.

==Session API==

:As stated above, the session has two main functions: 1) to connect to a sensor and read data from it, and 2) To handle the submission and execution of commands. Every session must extend the SensorSession abstract class at some level. However, most SensorSession implementations won't extend the SensorSession abstract class directly and will instead take advantage of one of the other abstract classes that provide some basic functionality.

===Active vs Passive Sessions===
:The first thing to figure out when creating the session class is whether the session is active or passive.
;Active Sessions
: An active session is one in which it is possible to send commands to the sensor. For example, the AlienSession is active because it is possible to send a command such as 'get taglist'. An LLRPSession is active because it can send GET_ROSPEC messages. A database session would probably be active since you would probably want to submit SQL queries to it. In fact, most sessions will probably be active ones.
;Passive Sessions
: Passive session simply listen for the sensors to push tag reads to them. They cannot send commands to the sensor. The only example of this kind of session at the moment is the AlienAutonomousSession. It simply opens up a port and listens for tag reads to be pushed to it by an Alien Reader operating in autonomous mode.

Please note that this active/passive terminology has nothing to do with active and passive RFID tag technology.

===Communication Channel===

:The next thing to figure out about the sensor you are connecting to is the medium of communication. Many sensors are networked and use TCP/IP. However, the Sensor API is channel-agnostic, and it is possible to connect to sensors that use USB or serial, for example. Currently, the Sensor API only has base classes that handle the work of connecting to TCP/IP sensors. If the sensor is USB or serial, you will need to write this functionality yourself.

===Tag Request Model===

:Active SensorSession normally operate in one of two ways when receiving tag data from a sensor
;Poll
: In this case the SensorSession will request that the Sensor send back its tag data immediately. An example of this is the Alien's 'get taglist' command.
;Push
:In this case, the SensorSession will configure the Sensor to send back tag data continuously until some stop trigger happens (e.g. sending a stop command)

===Java API Availability===

:Sometimes the manufacturer of the sensor provides a java API that handles the connection to the sensor. If so, you can use this API. You will need to turn the supplied jar into an OSGi bundle if it is not one already. This can be accomplished by using the "new plug-in project from existing jar" wizard from eclipse.

===SensorSession Hierarchy ===

:There are several base classes you can extend in the Sensor API that provide useful SensorSession functionality.
*SensorSession - This is the class at the root of the hierarchy. It has many abstract methods for concrete classes implement.
**AbstractSensorSession - This is an abstract class that extends SensorSession by adding functionality for submitting and killing commands. All concrete SensorSessions will probably at least want to extend this class. If your sensor has an API that manages the communication channel for you, or if your sensor does not use TCP/IP you will want to extend this class directly. For an example of a SensorSession that extends this class directly see the LLRPSession
***AbstractIPSensorSession - This is a base class for a SensorSession that uses TCP/IP. It handles socket I/O and threads. This class will not normally be extended directly by concrete implementations. Instead, concrete implementations should extend one of the following two classes:
****AbstractPollIPSensorSession - This class should be extended by sensor sessions that use TCP/IP communication and operate by periodically polling the sensor for tag data. See AlienSensorSession for an example
****AbstractPubSubIPSensorSession - This class should be extended by sensor sessions that use TCP/IP communication and operate by configuring the sensors to push data back to them. See the AwidSensorSession as an example.
***AbstractServerSocketSensorSession - This class should be used by passive sessions that use TCP/IP communication. See AlienAutonomousSensorSession for an example.

===Creating Session Objects===

:The SensorSession has two main functions: 1) To connect to a sensor (over a network, serial, usb, etc) and to read data from it, and 2) To manage [[#Short Introduction to the Command Framework | commands]] that have been submitted. Many sensors offer a networked TCP/IP interface. The Rifidi Sensor API offers abstract classes that other classes can extend which will take care of the TCP sockets and threads. If the manufacturer of the sensor makes a java API available to connect to the sensor, the Rifidi Sensor API allows you to use that instead.

[[Image:Sensorapi.png|none|location=center|thumb|600px| This image shows the relationship between the three main classes needed to create a plugin for the Rifidi Sensor Abstraction Layer. Only a few important methods are shown in each class, just to give the reader an idea about what the class does]]

:The sensor object's most important functionality is to create sessions. Most sensors will only have one session active at a time, however the API is designed to allow sensors to have multiple sessions. There are two methods for creating sensor sessions. The one that takes a SessionDTO is used to recreate persisted sessions.

==Sensor API==

:After creating your Session class, its time to create the sensor classes. It is composed by sensor, sensor factory and sensor session. The sensor class should extend the AbstractSensor class. There are two important pieces to the Sensor class.

=== Creating the Command Classes ===

:The Sensor object's main duty is to create SensorSession objects. There is normally one Sensor object for each physical sensor in the RFID system. For example, if your system has one Alien reader at a Dock Door and one at a weigh station, then there would be two instances of the AlienSensor object. Sensors also normally have getter-setter methods for setting properties of that sensor. For example, it is common for sensors to have methods to get and set the IP and port of the sensor to connect to. These properties are then used when creating new sessions. It is possible for a sensor to have more than one session (certain sensors (such as a database plugin) may support parallel sessions), but it is common for the sensor to allow only one session at a time.

====Property Getters and Setters====

:The sensors expose getter and setters methods to allow users to configure the sensor. These getter and setter methods are also used to recreate sensors from persistence. Each getter and setter method pair has an @Property annotation over the getter method. This exposes the property to workbench via Mbeans objects.

:One important thing to understand is that sessions are immutable; Once they are created, users cannot adjust properties on them. For example, suppose a sensor exposes a port property. A user can adjust this property using the getter/setter methods. Once the session is created however, changing the port property has no effect on the created session. To modify the port on the session, the user must destroy the session and create a new one.

====SensorFactory====

:The sensor factory creates new Sensors when the createInstance method is called. There is one instance of SensorFactory per sensor type. For example, in a running instance of the Edge Server, there is only one instance of an AlienSensorFactory which can create multiple instances of AlienSensor objects. The SensorFactory is normally created in the spring.xml of a sensor plugin and registered in the OSGi service registry in the osgi.xml.

:All concrete implementations should extend the AbstractSensorFactory class. Most AbstractSensor factories will need to have two object injected by Spring:
;NotifierService
: This service allows the sensor and sensorSession to notify clients (such as workbench) when an important event happens such as a session being created. For more information on this service see [[Edge_Server_Architecture#Notification_Service | this page]].
;JMSTemplate
: Tag events need to be placed on the internal JMS queue. The template is a helper object from Spring that makes it easy to send JMS notification messages. For more information about JMS in the Edge Server see [[EdgeServerJMS | this page]].

== Command API ==

:Although command and sensor classes can exist in the same bundle, it is encouraged to separate out these into separate bundles. This allows commands to be updated at runtime without bringing down a whole sensor bundle.

:The SensorSession objects execute commands from the Command framework. The command framework enables commands to be created and configured. There are three main components to the command framwork:

;CommandConfigurationFactory
:A CommandConfigurationFactory produces CommandConfiguration objects. There is one instance of a CommandConfigurationFactory for every command type. For example, the Alien sensor plugin has three command types available to it: Alien-Poll, Alien-Push-Start, and Alien-Push-Stop. That means there are three factories instantiated when the plugin starts. The factories are created in the spring.xml and registered in the OSGi registry in the osgi.xml.

;CommandConfiguration
: A CommandConfiguration produces commands. Users can modify parameters of a Command by using the properties exposed through the @Property annotations and getter/setter methods.

;Command

: A command is a runnable that wraps some logical piece of communication with a sensor. For example, the LLRPConfigure command configures the LLRP command to send back tag reads. To do this, it sends several LLRP messages. Some commands should be scheduled for repeated execution, while others should only execute once. Regardless, the run() method inside a command should execute quickly (i.e. there should be no loops that wait on I/O or sleep).

===Creating the Command Classes===

:For each kind of command that you have, you need to implement three classes:

# A Command class that extends the Command abstract class. The run method is where the functionality goes. You can call super.sensorSession to get a hold of the session which can be used to send or receive data.
# A CommandConfiguration class that extends AbstractCommandConfiguration. This class should produce commands. Like the Sensor class, it can have getter/setter methods which allow users to change property values of the CommandConfiguration. Again, once a command has been created, the properties on it cannot change.
# A CommandConfigurationFactory class that extends AbstractCommandConfigurationFactory.

=Creating Factories and registering them with OSGi Service Registry=
All factories (both SensorFactories and CommandConfigurationFactories) must be created and registered using Spring.

==Sensor Factories==
The following is an example of a SensorFactory being created in the spring.xml
<pre>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">


<bean id="factory"
class="org.rifidi.edge.readerplugin.thingmagic.ThingmagicReaderFactory">
<property name="context" ref="bundleContext" />
<property name="template" ref="internalMB" />
<property name="notifierService" ref="JMSNotifierService" />
<property name="commandConfigurations" ref="thingmagicCommands" />
</bean>

</beans>
</pre>
This code below belongs to the osgi.xml. It shows 1) How to register a sensor factory in the OSGi registry and 2) How to get references to the notifier service and the JMS template so that they can be injected into the factory in the above XML.
<pre>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:osgi="http://www.springframework.org/schema/osgi"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/osgi
http://www.springframework.org/schema/osgi/spring-osgi.xsd">


<osgi:service id="thingmagicConfigurationFactoryService" ref="factory">
<osgi:interfaces>
<value>org.rifidi.edge.core.configuration.ServiceFactory</value>
<value>org.rifidi.edge.core.sensors.base.AbstractSensorFactory</value>
</osgi:interfaces>
</osgi:service>


<osgi:set id="thingmagicCommands" interface="org.rifidi.edge.core.sensors.commands.AbstractCommandConfiguration"
cardinality="0..N" filter="(reader=ThingMagic)">
<osgi:listener ref="thingmagicConfigurationFactory" bind-method="bindCommandConfiguration" unbind-method="unbindCommandConfiguration"/>
</osgi:set>


<osgi:reference id="JMSNotifierService"
interface="org.rifidi.edge.core.services.notification.NotifierService" />


<osgi:reference id="internalMB"
interface="org.springframework.jms.core.JmsTemplate" bean-name="internalJMSTemplate" />
</beans>
</pre>

Notice how these work together: each ref attribute references the ID attribute of another bean. For example, in the spring.xml a bean is created with an id of "factory". The <tt>osgi:service</tt> tag references this ID in the osgi.xml.

It is also important that the filter value in the osgi:set is set to the ID of the sensor factory.

==Command Factories==
The following show the CommandFactories being created for the Alien Sensor:
<pre>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:osgi="http://www.springframework.org/schema/osgi"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/osgi
http://www.springframework.org/schema/osgi/spring-osgi.xsd">

<bean id="alienGetTagListCommandConfigurationFactory"
class="org.rifidi.edge.readerplugin.alien.commands.AlienGetTagListCommandConfigurationFactory">
<property name="context" ref="bundleContext" />
</bean>
<bean id="alienAutonomousModeCommandConfigurationFactory"
class="org.rifidi.edge.readerplugin.alien.commands.AlienAutonomousModeCommandConfigurationFactory">
<property name="context" ref="bundleContext" />
</bean>
<bean id="alienAutonomousModeStopCommandConfigurationFactory"
class="org.rifidi.edge.readerplugin.alien.commands.AlienAutonomousModeStopCommandConfigurationFactory">
<property name="context" ref="bundleContext" />
</bean>
</beans>
</pre>

=Using @Property annotations=

Engine RMI Interface

2011-11-06T00:09:52Z

Jerrito:

[[category:developerDoc]] [[category:EmulatorDoc]] [[category:EngineImplementation]]
RMI (Remote Method Invocation) is an architecture that allows clients to invoke methods on remote machines. Rifidi uses this architecture to allow the IDE (and the Tag Streamer) to communicate with the reader. It uses the [https://cajo.dev.java.net/ cajo] library to provide the RMI functionality.
=Purpose of RMI Architecture=
The basic goal of implementing RMI in Rifidi is so that one client (i.e. the IDE or Tag Streamer) can transparently control multiple readers on different machines, if need be. This enables a distributed architecture that will allow rifidi to drive performance testing of edge servers, because multiple machines can run rifidi readers, thus distributing the load across a network of computer. At the same time, however, it should be easy to start up one or two readers on a local machine for compatibility testing or to simply experiment with a reader.
==Architecture Diagram==
[[Image:RMI_Architecture.png|thumb|800px|none|A figure depicting the purpose of RMI in Rifidi]]
==Architecture Components==
;Client
:The client (such as the IDE, Tag Streamer, or Designer) runs on a local machine. Its purpose is to allow the user to manipulate readers (i.e. start, stop, add tags, etc).
;Reader Server
:The Reader Server manages one or more readers on a [http://www.supplementstoweightloss.com/ weight loss pills] particular machine by creating and destroying readers. There is one instance of a reader manager per machine.
;Reader
:A reader is the program that emulates a particular reader, such as an LLRP Reader. There can be multiple instances of a reader on a single machine.

One important aspect of this architecture is that The client doesn't care if a Reader Server is local or remote. That fact is transparent to the client.

=Introduction to Cajo and RMI=
Cajo is "a small, free library, enabling powerful dynamic multi-machine cooperation; both within and between, both free and proprietary Java applications. It provides a surprisingly easy to use, yet completely understandable framework to dramatically simplify the use of RMI; whilst at the same time harnessing its full potential." (https://cajo.dev.java.net/). If you are not familiar with cajo and/or RMI, you should read through the examples on cajo's website and wiki.
==Typical Usage==
[[Image:Cajo_architecture.png|thumb|800px|none|A block diagram explaining the basics of the cajo server]]

The above diagram shows how the cajo server typically works. The cajo process is started as a process on a particular port (normally 1198) on a server. Now java objects can bind themselves to the cajo server. This means that the cajo server enters a name-value pair in a table (called the registry). The name is a unique string used to [http://www.shoppharmacycounter.com/ weight loss pills] locate the reference to the object. The client can then use this name to get a copy of the object using the getItem() method.

==Remote Interfaces==
One of the advantages of cajo is that it allows an object to easily expose functionality through an interface that another object can get and use. The advantage to using an interface as opposed to invoking calls using text is that typechecking can be done at compile time.

For example, suppose Object_A looked like this:
<pre>
public class Object_A implements Serializable{

private static final long serialVersionUID = 1L;

private int value=0;

public void incrementValue(){
value ++;
}

public String getValue(){
return "object A's value is: " +Integer.toString( value);
}

}
</pre>

A simple way that a client could access Object_A's functionality is like this:
<pre>
Object object = Remote.getItem("//serverHost:1198/obj_a");
Remote.invoke(object, "incrementValue", null);
String s = (String)Remote.invoke(object, "getValue", null);
</pre>

However, another way that the client could access Object_A's functionality is if Object_A implemented an interface that exposed its methods that are available via RMI. For example, suppose there was an interface that looked like this:
<pre>
public interface Object_A_Interface {

public abstract void incrementValue();

public abstract String getValue();

}
</pre>

Now Object_A looks like this:
<pre>
public class Object_A implements Serializable, Object_A_Interface{

private static final long serialVersionUID = 1L;

private int value=0;

/* (non-Javadoc)
* @see org.rifidi.sandbox.cajo.test.Object_A_Interface#incrementValue()
*/
public void incrementValue(){
value ++;
}

/* (non-Javadoc)
* @see org.rifidi.sandbox.cajo.test.Object_A_Interface#getValue()
*/
public String getValue(){
return "object A's value is: " +Integer.toString( value);
}

}
</pre>

A client can now access Object_A's functionality by getting an interface and calling the methods. This enables the compiler to throw errors if something is wrong.

<pre>
Object_A_Interface obja = (Object_A_Interface) TransparentItemProxy.getItem(
"//serverHost:1198/obj_a",
new Class[] { Object_A_Interface.class });
obja.incrementValue()
String s = obja.getValue();
System.out.println(s);
</pre>

==Callbacks==
Another advantage of using RMI and cajo is that it allows for callbacks. This means that a client can call methods on a server using the method above, and the server can also invoke methods on the client using a similar method. This is important for Rifidi in situations with the GUI needs to be updated based on changes in the reader, such as when a TagID changes or when a GPO line goes high.

=Rifidi RMI Implementation=
This section describes how RMI is implemented in Rifidi.
==RMI Class Diagram==
[[Image:RMI_Class_Diagram.png|thumb|800px|none|A UML Class Diagram depicting the components of the RMI Architecture in Rifidi]]
==RMI Class Diagram Components==

===Client Components===
;RifidiClient
:The client is the program that the user controls the reader with (such as the IDE, Tag Streamer, or Designer).
;ClientCallbackManager
:The callback manager is the object that handles callbacks from the readers. Callbacks happen when something on the reader changes that the IDE needs to know about to update a GUI component, such as a Tag ID changing or a GPO line toggle. There is one callback manager per reader in the IDE.
;RifidiClientInterface
:The client Interface is the set of method calls that the client callback manager exposes to the readers.
===Reader Server Components===
;RifidiManager
:The rifidiManager is the object that manages readers on a specific machine. There is exactly one RifidiManager per machine. It is in charge of keeping track of the readers (i.e. creating and destroying). There are two distinct ways to start the manager, depending on how it is to be used.
# '''Remotely''' If you wish to start the server on a remote machine, you must use the RifidiManager's main method to start it running. The client will now need to know the RifidiManager's IP and port (normally the port is cajo's default port of 1198).
# '''Locally''' If the RifidiManger is to be started locally, a method is provided so that the client can do it programmaticly. This method is provided for convenience, so that It is simpler for the user when he just wants to start up the IDE and play around with a reader.
;RifidiManagerInterface
:The RifidiManagerInterface is the set of method calls that the RifidiManager exposes to the client.

===Reader Components===
;ReaderModuleManager
:The ReaderModuleManager is the wrapper around a reader on a machine. There is one ReaderModuleManager per instantiated reader.
;ReaderModuleInterface
:The ReaderModuleInterface represents the methods that a reader exposes to the client.

==RMI in action: An example==
This example consists of a timing diagram that goes through a typical usage of the RMI implementation in Rifidi. In this example, The client (IDE) and the server (RifidiManager) are on a local machine. This is typical of how the IDE is used, because a user norally just wants to start playing around with [http://www.mmesquire.com/ accident attorney Visalia] readers and does not care if the server is on a separate computer. After the client creates and starts the reader, it add tags to it. Then the client program to the reader will change the ID of a tag, which requires that the reader inform the IDE through an RMI callback.
===Timing Diagram===
[[Image:RMI_Timing_Diagram.png|thumb|1000px|none|A UML Class Diagram depicting the components of the RMI Architecture in Rifidi]]
===Explanation of Diagram===
# Because this RifidiManager is being run locally to the IDE, the IDE can start the RifidiManager itself. In this way, the user does not have to start the RifidiManager using its main method.
## Once the RifidiManager is start, it must register itself on the cajo RMI server so that the IDE can get it.
# Now that the RifidiManager is started the client needs to get the RifidiManagerInterface from the cajo RMI server so that it can call methods. If the RifidiManager were to be started on a remote machine, step one would not be needed (because the user would start up the server using the main method), and instead, this would be the first step. See [[Engine_RMI_Interface#Remote Interfaces | How to use Remote Interfaces]]
# The client now needs to tell the RifidiManger to create a reader. It does this by calling the createReader() method and passing in the GeneralReaderPropertyHolder which is an object that contains all the necessary information about how to start up a reader (reader class name, number of antennas, etc.)
## The RifidiManager will create the reader using the ReaderModuleFactory and pass the module to the ReaderModuleManager, which is an object that wraps a reader in order to expose an API to the client.
## Now that the reader module is created and wrapped by a ReaderModuleManager, the RifidiManager binds the ReaderModuleManager to the cajo server so that it is accessible to the client.
#The client creates a clientCallbackManager that will correspond to the reader that was just created. The reader will use this object when it needs to make a callback
#The reader gets the ReaderModule's interface from the cajo server
#The client calls the getClientProxy() method on the reader. This will create a proxy on the reader that it will use for the callback manager.
#The client binds this clientProxy object to the callback manager object that it has created. Now the reader can access the callback manager correctly.
#The client calls the reader's turnOn() method in order to (surprise!) turn on the reader.
## The turnOn() method call triggers the readerModuleManager to turn on the module which it wraps.
#Now the client wants to add tags to the reader, so it calls the reader module manager's addTags methods
## Again, the readerModuleManager acts as a wrapper and calls the module's addTagsMethod.
#At this point the reader's client (The program that controlls the reader, such as an edgeserver) changes the EPC ID of a tag
##This change requires the reader to notify the IDE through the use of the callback manager, so the reader uses the tagIDChanged() method in the callback manager.
###The callbackManager calls the necessary methods in the IDE to [http://www.andrewflusche.com/ Fredericksburg DUI Lawyer] reflect the change.

=Reference Client=

TagStreamerArchitecture

2011-11-06T00:08:52Z

Jerrito: /* The PathItem */

= Tag Streamer 2.0 =

As we talk about Tag Streamer 2.0 we talk about a new Software. The software comes along with Objects and object orientated programming. One of the modern software development concepts is the "Model Viewer Controller" principle. It defines 3 main parts of a program.

* the Viewer
* the Model
* the Controller

== The Viewer ==
The Viewer will be defined in a later phase of the implementation because the main task of Tag Streamer will be the execution of predefined XML files.

== The Model ==
The Model represents the input data. In Tag Streamer we can identify 4 parts.

* the Batch
* the Scenario
* the Components
* the LoadTestSuite

=== The Batch ===
Describes what should be done on the PathItems along the Scenario.

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<batch id="0">
<waitAction>
<waitTime>100</waitTime>
</waitAction>
<tagAction>
<execDuration>200</execDuration>
<number>20</number>
<prefix>eef</prefix>
<tagGen>GEN2</tagGen>
<tagType>CustomEPC96</tagType>
</tagAction>
<waitAction>
<waitTime>100</waitTime>
</waitAction>
<gpiAction>
<port>0</port>
<signal>true</signal>
</gpiAction>
</batch>
</pre>

=== The Scenario ===
Describes how the PathItems are connected to each other [http://www.supplementstoweightloss.com/ best weight loss] to simulate a assembly line in a factory.

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<scenario>
<pathUnit>
<readerID>0</readerID>
<travelTime>400</travelTime>
</pathUnit>
<pathUnit>
<readerID>0</readerID>
<travelTime>400</travelTime>
</pathUnit>
<pathUnit>
<readerID>0</readerID>
<travelTime>400</travelTime>
</pathUnit>
</scenario>
</pre>

=== The Components ===
Describes the affected devices in the PathItems. That can be RFID readers and in the future some more devices along a assembly line.

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<componentList id="0">
<readerComponents id="0">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10101</value>
</entry>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5084</value>
</entry>
</propertiesMap>
<readerClassName>org.rifidi.emulator.reader.llrp.module.LLRPReaderModule</readerClassName>
<readerName>LLRPreader</readerName>
<readerType>LLRPReader</readerType>
</reader>
</readerComponents>
<readerComponents id="1">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10102</value>
</entry>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5085</value>
</entry>
</propertiesMap>
<readerClassName>org.rifidi.emulator.reader.llrp.module.LLRPReaderModule</readerClassName>
<readerName>LLRPreader2</readerName>
<readerType>LLRPReader</readerType>
</reader>
</readerComponents>
</componentList>
</pre>

=== The LoadTestSuite ===
Describes how many Scenarios are executed and how are the Batches are connected to the scenarios, the speed new batches are created and how long the wait time will be until it's executed again.

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<loadTestSuite>
<fileUnits>
<fileName>scenario.xml</fileName>
<fileType>SCENARIO</fileType>
</fileUnits>
<fileUnits>
<fileName>scenario2.xml</fileName>
<fileType>SCENARIO</fileType>
</fileUnits>
<fileUnits>
<fileName>batch.xml</fileName>
<fileType>BATCH</fileType>
</fileUnits>
<testUnit>
<batchID>1</batchID>
<rampTime>4000</rampTime>
<scenarios>
<id>1</id>
<id>2</id>
</scenarios>
</testUnit>
<testUnit>
<batchID>1</batchID>
<rampTime>4000</rampTime>
<scenarios>
<id>1</id>
</scenarios>
</testUnit>
<testUnit>
<batchID>1</batchID>
<rampTime>4000</rampTime>
<scenarios>
<id>1</id>
<id>2</id>
</scenarios>
</testUnit>
</loadTestSuite>
</pre>

== The Controller ==
The Controller specifies how the input data will be processed. A example "use case" is provided here: [[TagStreamerSpecification]].

As parts of the controller we can identify the following components:

* the BatchGenerator
* the PathItem
* the LoadTestProcessor

=== The BatchGenerator ===
It uses the Batch as input data and creates the BatchItems which are floating through the Scenario.

=== The PathItem ===
A thread which will take a Batch as input and execute the [http://www.shoppharmacycounter.com/t-dietpillsonline.aspx diet pills] the defined operations in it.

=== The LoadTestProcessor ===
A Thread which takes the LoadTestSuite as input and creates all the necessary objects to operate.

TagStreamerArchitecture

2011-11-06T00:08:19Z

Jerrito:

= Tag Streamer 2.0 =

As we talk about Tag Streamer 2.0 we talk about a new Software. The software comes along with Objects and object orientated programming. One of the modern software development concepts is the "Model Viewer Controller" principle. It defines 3 main parts of a program.

* the Viewer
* the Model
* the Controller

== The Viewer ==
The Viewer will be defined in a later phase of the implementation because the main task of Tag Streamer will be the execution of predefined XML files.

== The Model ==
The Model represents the input data. In Tag Streamer we can identify 4 parts.

* the Batch
* the Scenario
* the Components
* the LoadTestSuite

=== The Batch ===
Describes what should be done on the PathItems along the Scenario.

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<batch id="0">
<waitAction>
<waitTime>100</waitTime>
</waitAction>
<tagAction>
<execDuration>200</execDuration>
<number>20</number>
<prefix>eef</prefix>
<tagGen>GEN2</tagGen>
<tagType>CustomEPC96</tagType>
</tagAction>
<waitAction>
<waitTime>100</waitTime>
</waitAction>
<gpiAction>
<port>0</port>
<signal>true</signal>
</gpiAction>
</batch>
</pre>

=== The Scenario ===
Describes how the PathItems are connected to each other [http://www.supplementstoweightloss.com/ best weight loss] to simulate a assembly line in a factory.

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<scenario>
<pathUnit>
<readerID>0</readerID>
<travelTime>400</travelTime>
</pathUnit>
<pathUnit>
<readerID>0</readerID>
<travelTime>400</travelTime>
</pathUnit>
<pathUnit>
<readerID>0</readerID>
<travelTime>400</travelTime>
</pathUnit>
</scenario>
</pre>

=== The Components ===
Describes the affected devices in the PathItems. That can be RFID readers and in the future some more devices along a assembly line.

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<componentList id="0">
<readerComponents id="0">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10101</value>
</entry>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5084</value>
</entry>
</propertiesMap>
<readerClassName>org.rifidi.emulator.reader.llrp.module.LLRPReaderModule</readerClassName>
<readerName>LLRPreader</readerName>
<readerType>LLRPReader</readerType>
</reader>
</readerComponents>
<readerComponents id="1">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10102</value>
</entry>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5085</value>
</entry>
</propertiesMap>
<readerClassName>org.rifidi.emulator.reader.llrp.module.LLRPReaderModule</readerClassName>
<readerName>LLRPreader2</readerName>
<readerType>LLRPReader</readerType>
</reader>
</readerComponents>
</componentList>
</pre>

=== The LoadTestSuite ===
Describes how many Scenarios are executed and how are the Batches are connected to the scenarios, the speed new batches are created and how long the wait time will be until it's executed again.

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<loadTestSuite>
<fileUnits>
<fileName>scenario.xml</fileName>
<fileType>SCENARIO</fileType>
</fileUnits>
<fileUnits>
<fileName>scenario2.xml</fileName>
<fileType>SCENARIO</fileType>
</fileUnits>
<fileUnits>
<fileName>batch.xml</fileName>
<fileType>BATCH</fileType>
</fileUnits>
<testUnit>
<batchID>1</batchID>
<rampTime>4000</rampTime>
<scenarios>
<id>1</id>
<id>2</id>
</scenarios>
</testUnit>
<testUnit>
<batchID>1</batchID>
<rampTime>4000</rampTime>
<scenarios>
<id>1</id>
</scenarios>
</testUnit>
<testUnit>
<batchID>1</batchID>
<rampTime>4000</rampTime>
<scenarios>
<id>1</id>
<id>2</id>
</scenarios>
</testUnit>
</loadTestSuite>
</pre>

== The Controller ==
The Controller specifies how the input data will be processed. A example "use case" is provided here: [[TagStreamerSpecification]].

As parts of the controller we can identify the following components:

* the BatchGenerator
* the PathItem
* the LoadTestProcessor

=== The BatchGenerator ===
It uses the Batch as input data and creates the BatchItems which are floating through the Scenario.

=== The PathItem ===
A thread which will take a Batch as input and execute the [SITE!!!!!!!!!!!!!!!!!!!!!!!!!! TITLE!!!!!!!!!!!!!!!] the defined operations in it.

=== The LoadTestProcessor ===
A Thread which takes the LoadTestSuite as input and creates all the necessary objects to operate.

Development and Release Process

2011-11-06T00:07:13Z

Jerrito:

This document describes the development and release processes for the products in the Rifidi Suite as well as various conventions that developers should be following. This document is intended for developers who are fairly familiar with the Rifidi code base, especially with eclipse and OSGi concepts.
=Goals=
# Standardize the development and release processes for Rifidi Developers
# Enable a relatively lightweight release process that is able to be extended later by a fully automatic build tool like maven
# Define a common set of conventions to use when checking in, checking out, and tagging code.

This document is not intended to be a "how to" guide for eclipse, but rather to define some common operating procedures around how code is developed and released in the Rifidi project

=Concepts=
==Target Platforms==
===About Target Platforms===
A target platform is the set of base plugins that your application depends on. Normally when you build a project in eclipse that uses eclipse functionality (SWT, JFace, etc), eclipse gets that functionality from the plugins and features folder located in you eclipse installation. Therefore it is using your eclipse base installation as your target platform. However, it is possible to define your own target platform for the application you are building rather than relying on the default one. Doing this is useful for several reasons
# It creates a separation between the plugins you use in your developing environment and the plugins used by your application. This means that you can, for example, upgrade the eclipse you use as your IDE without upgrading the plugins used by your application. Also, you can add plugins to your application without using them in your IDE. For example suppose you want to use the GEF bundles in your application, but you don't want them inside your eclipse development environment.
# A closely related advantage is that you can limit the plugins that are available to your application. If you use the base eclipse installation as your target platform, all of the plugins are available to your application. This makes it easy for application developers to simply add dependencies as they like. However, because an added dependency often means changes to other things, such as build processes, adding bundle dependencies should require some deliberation. Having a target platform simply makes bundle dependencies more explicit.
# It is possible to place more than just eclipse base plugins in the custom target platform. You can put bundles in there that you have built that are required for you application. This means that you could put, for example, tagged, stable versions of all of the plugins in your application in your target platform. Then when you need to modify a plugin, you can check out the source code from svn. Because eclipse will look in your workspace before it looks in your target platform [http://www.supplementstoweightloss.com/t-dietpills.aspx diet pills], it will find that plugin first. This means developers only have to check out code for bundles that they want to modify, which forces him to think about the code that he wants to write. It also means that, because the code in the target platform is tagged and stable, that if one developer checks in code with a change in it that breaks another plugin, that other developers can continue developing with the stable bundles in the target platform.
===Target Platforms in Rifidi===
Each major Rifidi project in the Rifidi suite should have its own target platform. For example, there is a target platform called <code>org.rifidi.emulator.target</code>. There should be a directory in the target platform called <code>rifidi</code> where all the bundle binaries that are required for that particular project. In addition there are various target platforms used for deploying products, such as <code>org.rifidi.rcp.target</code>.

==Bundle Versioning==
All bundles in OSGi have version numbers, with the following form 1.2.3, where 1 is the major version, 2 is the minor version, and 3 is the point version. The Rifidi project uses the following conventions:
# The '''major''' version should be increased only if there is a major API change for the bundle. A major version change usually involve a change that would break another plugin, for example, changing a method signature. A good rule of thumb is that if bundle X depends on bundle Y and bundle X was modified as a result of the changes to bundle Y, then bundle Y had a major API change. For example, suppose bundle Y has a method called <code>foo()</code>. Suppose bundle X, for some reason, needs to pass in a string to <code>foo()</code>. So you modify <code>foo()</code> to become <code>foo(String string)</code>. This was a major change in bundle Y.
# The '''minor''' version should be increased if there is a minor API change. A minor API change is something that would not break existing compatibility with dependent bundles. For example, adding a method signature to a class, or adding more functionality to the bundle in the form of classes is a minor API change. The key difference between a minor and a major API change is that a minor API change will not cause other bundles that depend on it to break.
# The '''point''' version should be increased for small internal changes and bug fixes. These changes do not involve the bundle's API.

Note that it is not necessary to change the version numbers any time you submit. It is only necessary to modify the version numbers if the changes are relatively well tested and stable. For example, you might want to make some changes then submit the changes back to the trunk for another developer to look at, test, or modify. ''If you don't expect [http://www.shoppharmacycounter.com/ weight loss supplements] to make any further changes to the code, then you should modify then version number''

==Dependencies==
In OSGi there are two ways of specifying dependencies.
#'''Require-Bundle''' should be used for dependencies to bundles that contain code which is written for the Rifidi project. Usually, this is anything that begins with <code>org.rifidi.*</code>.
#'''Import-Package''' should be used for for dependencies to bundles that do not contain code that is maintained by the Rifidi project, for example, to third party libraries such as log4j, cajo, or eclipse base plugins such as SWT or GEF. It is also possible to find certain third party libraries that have already been made into a plugin at the eclipse [http://www.eclipse.org/orbit/overview.php eclipse orbit project].

The advantage to using Import-Package over Require-Bundle is that Import-Package is more flexible. The plugin is more flexible because it could use any loaded OSGi bundle that exposes that particular plugin with the given version constraints. In addition, because importing packages is more granular than requiring bundles, it makes the developer think a little more about the dependencies his is using.

In both Require-Bundle and Import-Package dependencies, the minimum version ''must'' be specified. It is also recommended that the maximum version be specified as well. This is because it is possible for more than one bundle with the same name but different versions to be loaded by OSGi during runtime. So if an incorrect version of a bundle is already loaded, but the bundle that requires that bundle does not specify the version it needs, bad things might happen.

A good way to specify versions is to have the minimum version be inclusive and the maximum version be exclusive. For example, if the minimum version is set to 2.2.0 inclusive and the maximum version is 2.3.0 exclusive, then any version starting with 2.2 is acceptable. This makes sense, because we have adopted a versioning scheme where the minor version number signifies a minor API change.

==SVN Structure==
There are four repositories used in Rifidi:
* <code>rep-external</code> - main repository for Rifidi development
* <code>rep-internal</code> - repository to hold code that is necessary, but that should not be released
* <code>rep-edge</code>
* <code>sandbox</code> - repository to hold projects for playing around with

<code>rep-external</code> and <code>rep-edge</code> are the main repositories for Rifidi development. They have the following structure:

*'''org.rifidi.binary'''
*: A project containing all the bundles as binaries for rifidi. It is used so that you don't have to check out the code when developing or releasing
* '''readme'''
*:a project that contains a text file that describes what all the bundles in trunk are used for
* '''rifidi'''
*: The code for the Rifidi project
** '''branches'''
*: If a developer want to add a major feature that requires alot of time, and he wants to check the code into the svn before he is ready to integrate the code back into the trunk, he can check the code into the branches directory
** '''tags'''
**: When a stable version of a bundle is reached, the code should be placed in a sub directory that has the name of the bundle's version. See [[Development and Release Process#Tags| Tags]] for a description of when to create a new tag
*** '''org.rifidi.bundle.a'''
**** 1.0.0 - contains eclipse project
**** 1.1.0 - contains eclipse project
**** 2.0.0 - contains eclipse project
*** '''org.rifidi.bundle.b'''
**** 1.0.0 - contains eclipse project
** '''trunk'''
**: The trunk contains the latest code for each bundle. It might be unstable. All changes to code should be made to the bundles located in the trunk
*** org.rifidi.bundle.a - contains eclipse project
*** org.rifidi.bundle.b - contains eclipse project

==Tags==
The purpose of tagging a bundle is to save the code at a stable point so that future changes can be reversed if they introduce a bug that older versions did not have. A new tag ''must'' be created in svn when either the major or the minor version number of the plugin is incremented. It is not required to create a new tag when the point version number is incremented, but it is ok to do so.

==Product File==
A product file defines the required plugins for a particular project. It is used to build the project. It is important to keep this file updated as new plugins are added or old ones are removed.

=Processes=
This section defines a few procedures that should be followed when developing code for the Rifidi project
==Setting up a development environment==
# Download the target platform for the project you are working with. For example, if you are developing a plugin for emulator, you would download the target platform for emulator
# Download <code>org.rifidi.binary</code>
# Download any bundles that you need to modify. For example, if you are making changes to the alien reader, download <code>org.rifidi.emulator.reader.alien</code>
# Set the target platform as the target platform for the workspace
# Clean the workspace

==Modifying an Existing Bundle==
Suppose you have modified an existing bundle and the changes are relatively stable and tested, and you are ready to integrate them back in with the rest of the project.

# If the changes you have made require a version change make sure that is done
# If you had to change the major or the minor version number, create a new svn tag for the plugin.
# Export the bundle as a binary bundle using the export wizard on the Manifest.MF file for the plugin
# Add the bundle to <code>org.rifidi.binary</code>
# Submit bundle changes and target platform changes back to trunk.

If you have made changes to a bundle but are not ready to integrate them back with the rest of the project, you can do one of two things:
# Submit them back to the trunk, but don't change the version numbers. This is ok to do because everyone else should be using tagged stable bundles in the target platform.
# Create a folder in the branches directory and put it there. Only do this if multiple developers are modifying the same plugin at the same time.

==Creating a new Bundle==
To create a new bundle called <code>org.rifidi.xyz</code>:
# Create a new plugin project with the name <code>org.rifidi.xyz</code>
# In the Manifest.MF file
## Add 'Pramari, LLC' as the provider
## Give the bundle a name such as 'Rifidi xyz'. It is important that the first word is 'Rifidi' so that all bundles created as a part of the Rifidi project are easy to locate when there are alot of bundles installed as part of an eclipse installation.
# Write the code for the plugin
# Follow the steps for [[Development and Release Process#Modifying and Existing Bundle| Modifying and Existing Bundle]]
# If you tagged the bundle and added it to the target platform, then make sure you add the new bundle and its dependencies to the product file
# Add an entry to the readme project at the top level of the svn

==Releasing a Product==
# Download the rifidi build target platform and set it as the target platform for your workspace
# Download the project that contains the product file for the project you are trying to build
# Export the project using the export wizard

TagStreamerUseCaseScenarios

2011-11-06T00:06:03Z

Jerrito:

=Starting up Tag Streamer alpha 2.0=
# Follow the [[Rifidi:Source_Code|instructions]] to download Rifidi Tag Streamer from source
## Download the following [[Tag_Streamer_Packages|packages]]
# Open up the Lauch Configuration wizard by going to run->Open Run Dialog... [[Image:Streamer-setup-osgi.png|thumb|800px|none]]
#Create a new OSGI Framwork launch configuration [[Image:Streamer-setup-plugins.png|thumb|800px|none]]
##Click 'Deselect All'
##Click the box next to org.rifidi.streamer
##Click 'Add Required Bundles'
##Click the boxes next to all the reader bundles (i.e. org.rifidi.emulator.reader.llrp, org.rifidi.emulator.reader.alien, etc)
##Click 'Apply'
##Click 'Run'
#The application should now fail with a FileNotFound Exception. You need to place the four XML files (loadTestSuite.xml, scenario.xml, components.xml, and batch.xml) into this directory

= Use Case: Bursts of tags =
This use case simulates scenarios when you have short bursts of tags on many readers, such as several dock doors. We define a scenario suite with five scenarios, each having one reader. You can think of this as having five dock doors. Then we define the actual readers in the components.xml. This defines what kind of reader will be used in the scenarios as well as some additional information about the readers, such as their IP address and how many GPIO ports they have. The batchSuite defines the patterns of tags that will be seen by the readers. The first thing that this batch does is wait for a random amount of time so that all batches do not start at the same time. We also define a pattern of 20 tags (number) that represent a burst. Finally a LoadTestSuite is defined that defines a)The path to the xml files that are used (scenario, components, and batch), and b) the execution structure. The execution structure has a number of times to run, a time to wait between loops, and a mapping between scenarios and batches. These mappings, called batchActions, define which batches each scenario should run. All of the batchActions happen in parallel [http://www.supplementstoweightloss.com/t-adipex.aspx adipex] (that is why we put a random wait time at the beginning of the batch -- so that
== Scenarios ==
The following scenario describes how the readers are located. In this special case all scenarios [http://www.shoppharmacycounter.com/ weight loss pills] consist of only one reader. Because none of these readers have following readers the traveltime is 0.

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<scenarioSuite>
<scenario id="1">
<pathItem>
<readerID>1</readerID>
<travelTime>0</travelTime>
</pathItem>
</scenario>
<scenario id="2">
<pathItem>
<readerID>2</readerID>
<travelTime>0</travelTime>
</pathItem>
</scenario>
<scenario id="3">
<pathItem>
<readerID>3</readerID>
<travelTime>0</travelTime>
</pathItem>
</scenario>
<scenario id="4">
<pathItem>
<readerID>4</readerID>
<travelTime>0</travelTime>
</pathItem>
</scenario>
<scenario id="5">
<pathItem>
<readerID>5</readerID>
<travelTime>0</travelTime>
</pathItem>
</scenario>
</scenarioSuite>
</pre>

== Components ==
This file describes all the components the streamer should load. In this case we describe 5 LLRP Readers. Wich will be emulated by RifidiEmulator.

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<componentSuite>
<readerComponents id="1">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5084</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10101</value>
</entry>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
</propertiesMap>
<readerClassName>
org.rifidi.emulator.reader.llrp.module.LLRPReaderModule
</readerClassName>
<readerName>LLRPReader1</readerName>
</reader>
</readerComponents>
<readerComponents id="2">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5085</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10102</value>
</entry>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
</propertiesMap>
<readerClassName>
org.rifidi.emulator.reader.llrp.module.LLRPReaderModule
</readerClassName>
<readerName>LLRPReader2</readerName>
</reader>
</readerComponents>
<readerComponents id="3">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5086</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10103</value>
</entry>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
</propertiesMap>
<readerClassName>
org.rifidi.emulator.reader.llrp.module.LLRPReaderModule
</readerClassName>
<readerName>LLRPReader3</readerName>
</reader>
</readerComponents>
<readerComponents id="4">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5087</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10104</value>
</entry>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
</propertiesMap>
<readerClassName>
org.rifidi.emulator.reader.llrp.module.LLRPReaderModule
</readerClassName>
<readerName>LLRPReader4</readerName>
</reader>
</readerComponents>
<readerComponents id="5">
<reader>
<numAntennas>1</numAntennas>
<numGPIs>4</numGPIs>
<numGPOs>4</numGPOs>
<propertiesMap>
<entry>
<key>llrp_inet_address</key>
<value>127.0.0.1:5088</value>
</entry>
<entry>
<key>inet_address</key>
<value>127.0.0.1:10104</value>
</entry>
<entry>
<key>servermode</key>
<value>true</value>
</entry>
</propertiesMap>
<readerClassName>
org.rifidi.emulator.reader.llrp.module.LLRPReaderModule
</readerClassName>
<readerName>LLRPReader5</readerName>
</reader>
</readerComponents>
</componentSuite>
</pre>

== Batch ==

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<batchSuite>
<batch id="1">
<waitAction>
<maxWaitTime>100</maxWaitTime>
<minWaitTime>200</minWaitTime>
<random>true</random>
</waitAction>
<tagAction>
<execDuration>200</execDuration>
<number>20</number>
<prefix>eef</prefix>
<regenerate>true</regenerate>
<tagGen>GEN2</tagGen>
<tagType>CustomEPC96</tagType>
</tagAction>
</batch>
</batchSuite>
</pre>

== LoadTestSuite ==

<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<loadTestSuite>
<fileUnit>
<fileName>components.xml</fileName>
<fileType>COMPONENT</fileType>
</fileUnit>
<fileUnit>
<fileName>batches.xml</fileName>
<fileType>BATCH</fileType>
</fileUnit>
<fileUnit>
<fileName>scenario.xml</fileName>
<fileType>SCENARIO</fileType>
</fileUnit>
<testUnit iterations="5000">
<waitAction>
<maxWaitTime>1000</maxWaitTime>
<minWaitTime>0000</minWaitTime>
<random>false</random>
</waitAction>
<batchAction>
<batchID>1</batchID>
<scenarioID>1</scenarioID>
</batchAction>
<batchAction>
<batchID>1</batchID>
<scenarioID>2</scenarioID>
</batchAction>
<batchAction>
<batchID>1</batchID>
<scenarioID>3</scenarioID>
</batchAction>
<batchAction>
<batchID>1</batchID>
<scenarioID>4</scenarioID>
</batchAction>
<batchAction>
<batchID>1</batchID>
<scenarioID>5</scenarioID>
</batchAction>
</testUnit>
</loadTestSuite>
</pre>