Class: T2Flow::Model

Inherits:
Object
  • Object
show all
Defined in:
lib/t2flow/model.rb

Overview

The model for a given Taverna 2 workflow.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Model

Creates an empty model for a Taverna 2 workflow.



31
32
33
34
 
# File 'lib/t2flow/model.rb', line 31

def initialize
  @dataflows = []
  @dependencies = []
end

Instance Attribute Details

#dataflows ⇒ Object

The list of all the dataflows that make up the workflow.



25
26
27
 
# File 'lib/t2flow/model.rb', line 25

def dataflows
  @dataflows
end

#dependencies ⇒ Object

The list of any dependencies that have been found inside the workflow.



28
29
30
 
# File 'lib/t2flow/model.rb', line 28

def dependencies
  @dependencies
end

Instance Method Details

#all_coordinations ⇒ Object

Retrieve ALL the coordinations found in a nested workflow



106
107
108
109
110
 
# File 'lib/t2flow/model.rb', line 106

def all_coordinations
  coordinations =[]
  @dataflows.each { |dataflow| coordinations << dataflow.coordinations }
  return coordinations.flatten
end

#all_datalinks ⇒ Object

Retrieve ALL the datalinks within a nested workflow



74
75
76
77
78
 
# File 'lib/t2flow/model.rb', line 74

def all_datalinks
  links = []
  @dataflows.each { |dataflow| links << dataflow.datalinks }
  return links.flatten
end

#all_processors ⇒ Object

Retrieve ALL the processors found in a nested workflow



93
94
95
96
97
 
# File 'lib/t2flow/model.rb', line 93

def all_processors
  procs =[]
  @dataflows.each { |dataflow| procs << dataflow.processors }
  return procs.flatten
end

#all_sinks ⇒ Object

Retrieve ALL the sinks(outputs) within the workflow



130
131
132
133
134
 
# File 'lib/t2flow/model.rb', line 130

def all_sinks
  sinks =[]
  @dataflows.each { |dataflow| sinks << dataflow.sinks }
  return sinks.flatten
end

#all_sources ⇒ Object

Retrieve ALL the sources(inputs) within the workflow



118
119
120
121
122
 
# File 'lib/t2flow/model.rb', line 118

def all_sources
  sources =[]
  @dataflows.each { |dataflow| sources << dataflow.sources }
  return sources.flatten
end

#annotations ⇒ Object

Retrieve the annotations specific to the workflow. This does not return any annotations from workflows encapsulated within the main workflow.



82
83
84
 
# File 'lib/t2flow/model.rb', line 82

def annotations
  self.main.annotations
end

#beanshells ⇒ Object

Retrieve ALL the processors containing beanshells within the workflow.



53
54
55
 
# File 'lib/t2flow/model.rb', line 53

def beanshells
  self.all_processors.select { |x| x.type == "beanshell" }
end

#coordinations ⇒ Object

Retrieve coordinations from the top level of a nested workflow. If the workflow is not nested, retrieve all coordinations.



101
102
103
 
# File 'lib/t2flow/model.rb', line 101

def coordinations
  self.main.coordinations
end

#dataflow(df_id) ⇒ Object

Retrieve the dataflow with the given ID



47
48
49
50
 
# File 'lib/t2flow/model.rb', line 47

def dataflow(df_id)
  df = @dataflows.select { |x| x.dataflow_id == df_id }
  return df[0]
end

#datalinks ⇒ Object

Retrieve the datalinks from the top level of a nested workflow. If the workflow is not nested, retrieve all datalinks.



69
70
71
 
# File 'lib/t2flow/model.rb', line 69

def datalinks
  self.main.datalinks
end

#get_processor_links(processor) ⇒ Object

For the given dataflow, return the beanshells and/or services which have direct links to or from the given processor. If no dataflow is specified, the top-level dataflow is used. This does a recursive search in nested workflows.

Usage

my_processor = model.processor[0]
linked_processors = model.get_processors_linked_to(my_processor)
processors_feeding_into_my_processor = linked_processors.sources
processors_feeding_from_my_processor = linked_processors.sinks



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/t2flow/model.rb', line 150

def get_processor_links(processor)
  return nil unless processor
  proc_links = ProcessorLinks.new

  # SOURCES
  sources = self.all_datalinks.select { |x| x.sink =~ /#{processor.name}:.+/ }
  proc_links.sources = []

  # SINKS
  sinks = self.all_datalinks.select { |x| x.source =~ /#{processor.name}:.+/ }
  proc_links.sinks = []
  temp_sinks = []
  sinks.each { |x| temp_sinks << x.sink }

  # Match links by port into format
  # my_port:name_of_link_im_linked_to:its_port
  sources.each do |connection|
    link = connection.sink
    connected_proc_name = link.split(":")[0]
    my_connection_port = link.split(":")[1]

    if my_connection_port
      source = my_connection_port << ":" << connection.source
      proc_links.sources << source if source.split(":").size == 3
    end
  end

  sinks.each do |connection|
    link = connection.source
    connected_proc_name = link.split(":")[0]
    my_connection_port = link.split(":")[1]

    if my_connection_port
      sink = my_connection_port << ":" << connection.sink
      proc_links.sinks << sink if sink.split(":").size == 3
    end
  end

  return proc_links
end

#local_workers ⇒ Object

Retrieve ALL local workers WITHIN the workflow



63
64
65
 
# File 'lib/t2flow/model.rb', line 63

def local_workers
  self.all_processors.select { |x| x.type =~ /local/i }
end

#main ⇒ Object

Retrieve the top level dataflow ie the MAIN (containing) dataflow



42
43
44
 
# File 'lib/t2flow/model.rb', line 42

def main
  @dataflows[0]
end

#model_id ⇒ Object

Retrieve the unique dataflow ID for the top level dataflow.



137
138
139
 
# File 'lib/t2flow/model.rb', line 137

def model_id
  self.main.dataflow_id
end

#name ⇒ Object

Retrieve the top level dataflow’s name



37
38
39
 
# File 'lib/t2flow/model.rb', line 37

def name
  main.name
end

#processors ⇒ Object

Retrieve processors from the top level of a nested workflow. If the workflow is not nested, retrieve all processors.



88
89
90
 
# File 'lib/t2flow/model.rb', line 88

def processors
  self.main.processors
end

#sinks ⇒ Object

Retrieve the sinks(outputs) to the workflow



125
126
127
 
# File 'lib/t2flow/model.rb', line 125

def sinks
  self.main.sinks
end

#sources ⇒ Object

Retrieve the sources(inputs) to the workflow



113
114
115
 
# File 'lib/t2flow/model.rb', line 113

def sources
  self.main.sources
end

#web_services ⇒ Object

Retrieve ALL processors of that are webservices WITHIN the model.



58
59
60
 
# File 'lib/t2flow/model.rb', line 58

def web_services
  self.all_processors.select { |x| x.type =~ /wsdl|soaplab|biomoby/i }
end