Diff for "Outdated_Cytoscape_3.0/CommandDiscussions"

Differences between revisions 26 and 27

Command Layer Definition

Command layer contains mechanism to make Cytoscape functions easily accessible from application layer. This layer should be separated from application layer and can be used in any mode: Desktop application, server version, and command line version.

Requirements

Command layer should be separated from application or UI.
Commands should be accessible from scripting (dynamic) languages.
Command history should be manageable by Undo manager (in application layer).
Extensible. Plugin writers and developers use Cytoscape as library can add their own commands.
Developers can chain commands to develop a workflow, like UNIX shell piping.

Command Usecases

(Not finished yet...)

Multiple Language Support

Commands should be easily accessible from dynamic (scripting) languages, including Python, Ruby, and JavaScript. This will be implemented using scripting language engins running on JVM (Jruby, Rhino, and Jython). This enables users to write simple tasks as scripts.

Functions Encapsulated as Command

In general, most of the classes in cytoscape.actions will be converted into Commands. In addition, some of the methods under the class cytoscape.Cytoscape will be encapsulated as command. Such as:

createNetwork()
createNewSession()
getNetwork()

Design

attachment:commandLayer1.png
Each command will be registered as an OSGi service.
Users (developers) access commands through the OSGi ServiceTracker.
For easy access to commands, an utility class CommandServiceManager will be implemented. This is a wrapper class for OSGi ServiceTracker.

How to Call Commands

// Java
Command c = CommandService.getCommand("command_name");
Object result = c.execute( parameters );

// Ruby
c = CommandService.getCommand("command_name")
result = c.execute( parameters )

We can implement similar functions Felix ShellService has:

package org.apache.felix.shell;

public interface ShellService
{
    public String[] getCommands();
    public String getCommandUsage(String name);
    public String getCommandDescription(String name);
    public ServiceReference getCommandReference(String name);
    public void executeCommand(
        String commandLine, PrintStream out, PrintStream err)
        throws Exception;
}

Like other layers, Command Layer will be distributed as a bundle. This bundle consists of the following:

Command interface: All commands should implement this interface.
Command implementations: Collection of actual implementations.
Command Service Manager: (will be discussed in the next section)

When plugin developer wants to add a new command to the system, the plucin bundle will depends on this.

Command Service Manager

Command Service Manager is a simple utility class to make all commands easily accessible from all parts of Cytoscape. Essentially, this is a custom version of ServiceTracker class. Since all commands are registered as OSGi services, command users access commands through OSGi service mechanism. However, it is better to wrap this with a simple API to hide the detail of the OSGi service mechanism. The CommandServiceManager API will be something like the following:

public class CommandServiceManager {
    public static Command getCommand(String command_name) {}
    public static List<String> getAvailableCommand() {}
}

This class is only for accessing (using) commands. Developers should register command implementations like other OSGi services (can be done with Spring-DM). Each command have a OSGi Service Property to represent that it is a Cytoscape command. This property will be used by the service tracker to filtering services.

Implementation

All commands should implement the following interface:

public interface Command {
        // Getters and Setters
        public String getName();
        public String getDescription();
        
        public void setName(String name);
        public void setDescription(String description);
        
        // Arguments for commands are name-value pairs.
        public Map<String, Object> getParameter() throws IllegalArgumentException;
        public void setParameter(Map<String, Object> args) throws Exception;
        
        // Execute the command.
        public void execute() throws Exception;
}

In 2.6, Tunable was a class to store parameters and their handlers. In 3.0, it is a Java Annotation. All fields in Command classes should be annotated by this Tunable, then command users can access those fields from Command interface:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Tunable {
        String description();
        boolean required();
}

In most cases, command developer can extend this super class. Validation of the arguments (parameters) should be done by private method implemented by the command developer.

public abstract class AbstractCommand {
        protected String name;
        protected String description;

        public String getDescription() {
                return description;
        }

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }

        public void setDescription(String description) {
                this.description = description;
        }

        public Map<String, Object> getParameter() throws IllegalArgumentException {

                final Map<String, Object> parameter = new HashMap<String, Object>();
                
                for (Field f : this.getClass().getDeclaredFields()) {
                        if (f.isAnnotationPresent(Tunable.class)) {
                                try {
                                        parameter.put(f.getName(), f.get(this));
                                } catch (IllegalAccessException e) {
                                        // Accessing private fields are allowed here.
                                }
                        }
                }
                return parameter;
        }

        public void setParameter(Map<String, Object> arg) throws Exception {

                for (Field f : this.getClass().getDeclaredFields()) {

                        // See if the field is annotated as a Tunable.
                        if (f.isAnnotationPresent(Tunable.class)) {
                                try {
                                        Tunable a = f.getAnnotation(Tunable.class);
                                        System.out.println("We're modifying Tunable:  "
                                                        + f.getName() + " : " + a.description());
                                        if (arg.containsKey(f.getName())) {

                                                // Handle the Tunables here.
                                                // Use handlers to process each data types.

                                        } else if (a.required()) {
                                                // required field is missing. Throw exception.
                                        }

                                } catch (Exception ex) {
                                        System.out.println("Modification failed: " + f.toString());
                                        throw ex;
                                }
                        }
                }

        }
}

Open Questions

How the events are handled?

Actual implementation of the Command looks like the following. Validation of the arguments are command writer's responsibility. Tunable-based setters and getters are type-safe, but does not include range checkers.

public class ImportGraphFileCommand extends AbstractCommand {

        @Tunable(description = "Location of the network file to be imported.", required = true)
        private URI fileLocation;

        public void execute() throws Exception {
                if(validate()) {
                        // execute the command
                } else {
                        // Throw invalid argument exception
                }
        }
        
        private boolean validate() {
                // Check required fields and value ranges here.
                return true;
        }
}

Commands with Dependency Injection Framework

With Spring Framework, the command layer will looks like the following:

Injecting name and description.

        <context:annotation-config />
        
        <context:component-scan
                base-package="org.cytoscape.command.internal" />

        <!-- Inject command properties -->
        <bean id="importGraphFileCommand"
                class="org.cytoscape.command.internal.ImportGraphFileCommand">
                <property name="name" value="importGraphFileCommand" />
                <property name="description" value="Load network file." />
        </bean>

Export the command as OSGi service

<osgi:service id="importGraphFileCommandOSGiService" auto-export="interfaces" ref="importGraphFileCommand" />

One of the advantages to use DI container is simpler integration test code.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"/META-INF/spring/bundle-context.xml"})
public class ExampleBeanIntegrationTest extends
                AbstractDependencyInjectionSpringContextTests {
        
        @Autowired
        private ImportGraphFileCommand command1;

        @Autowired
        private LayoutCommand command2;

        ...

        @Test
        public void testWorkflow() throws Exception {
                List<Object> parameter = new ArrayList<Object>();
                List<Class<?>> parameterType = new ArrayList<Class<?>>();
                
                parameter.add("testData/galFiltered.sif");
                parameterType.add(String.class);
                
                List<Object> result = command1.execute(parameter, parameterType);
                
                //Do something with other commands
                
        }
}

Commad Implemented with Dynamic Languages

From Spring 2.5, it has a [http://static.springframework.org/spring/docs/2.5.x/reference/dynamic-language.html built-in support for dynamic languages]. By using this feature, developers can implement commands with other languages and make it available other developers.

RubyCommand.rb

require 'java'

class RubyCommand
        include org.cytoscape.command3.Command
        
        # Command detail
        
end

Spring configuration file

        <lang:jruby id="rubyService"
                script-interfaces="org.cytoscape.command3.Command"
                script-source="classpath:RubyCommand.rb">
                <lang:property name="name" value="Command implemented by ruby." />
        </lang:jruby>

And Command Service Manager will be a class to holds a OSGi Service Tracker:

public final class CommandManager implements BundleActivator {

        private ServiceTracker commandServiceTracker;

        public Command getCommand(final String commandName){
            //returns the command using Service Tracker
        }

        public void start(BundleContext bundleContext) throws Exception {
                commandServiceTracker = new ServiceTracker(bundleContext, Command.class
                                .getName(), null) {
                        @Override
                        public Command addingService(ServiceReference serviceReference) {
                                Command command = (Command) super.addingService(serviceReference);
                                return command;
                        }
                };

                commandServiceTracker.open();
                
        }

        public void stop(BundleContext bundleContext) throws Exception {
                commandServiceTracker.close();
        }
}

References and External Links

Outdated_Cytoscape_3.0/CommandDiscussions (last edited 2011-02-24 15:33:09 by PietMolenaar)

-  ← Revision 26 as of 2008-06-13 03:44:46 →
  Size: 12213
  Editor: KeiichiroOno
  Comment:
+  ← Revision 27 as of 2008-06-13 03:52:57 →
  Size: 11288
  Editor: KeiichiroOno
  Comment:
-Deletions are marked like this.
+Additions are marked like this.
 Line 216:
-With DI container, the command layer will looks like the following:



One of the advantages to use DI container is simpler integration test code.



===== Example Command Implementation with Spring =====

{{{#!java

public abstract class AbstractCommand implements Command {



 protected String name;

 protected String description;



 public String getName() {

  return name;

 }



 public String getDescription() {

  return description;

 }

 

 public void setName(String name) {

  this.name = name;

 }

 

 public void setDescription(String description) {

  this.description = description;

 }



}

}}}
+With Spring Framework, the command layer will looks like the following:



 * Injecting name and description.
-Line 260:
+Line 233:
- * Commands will be created by Spring.
+ * Export the command as OSGi service

{{{

<osgi:service id="importGraphFileCommandOSGiService" auto-export="interfaces" ref="importGraphFileCommand" />

}}}



One of the advantages to use DI container is simpler integration test code.
-Line 315:
+Line 294:
-===== Tunable =====

'''''Tunable''''' class was introduced in Cytoscape 2.5 and it is used to provide mechanism to store editable parameters.  This can be re-implemented as an annotation.







==== Exporting OSGi Service by Spring-DM ====



If we use one command = one OSGi service style design, we can use [http://www.springframework.org/osgi Spring Dynamic Module] for managing service import/export.



{{{

<bean name="importGraphFileCommandService"

  class="org.cytoscape.command.impl.ImportGraphFileCommandService" />

}}}



{{{

<osgi:service auto-export="interfaces" ref="importGraphFileCommandService" />

}}}



And Command Manager will be a class to holds a OSGi Service Tracker:
+And Command Service Manager will be a class to holds a OSGi Service Tracker:
-Line 348:
+Line 311:
-   public Object addingService(ServiceReference serviceReference) {
+   public Command addingService(ServiceReference serviceReference) {