metababel 0.1.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f9cdd491e69bf7414791f771ed3902bb4d8ba27dd28c6b2e66bb677662a6c9d
-  data.tar.gz: 13c2e7c0c201b9a3f51d55e8ea9438284f77285ad6f8c640f20567c88e5f6f88
+  metadata.gz: 8622843bd93dc9b0e2ed91f3ad7bb444ea2216ba183651d17773de232749a187
+  data.tar.gz: 762a87b56229cee6bebe99ebb5358610672a6fb2a171718c3255ad079391ba85
 SHA512:
-  metadata.gz: a908872fc837088e86f43aa08ca113795287c35a3d249c140295c9471089cc418b8ff8cab7dc7817acb0193df5d42c2fd51d191cd63ef1d22539b0428d2c5180
-  data.tar.gz: e7d44bcafe7a4be48336a5da021f911b31db8877d06b7d7c6c3918ee520adbd51093567d9a502a6a52395b490d306b04ede726be97dceaea7b8e2b6276025993
+  metadata.gz: 0fbe1685dafbc6d45e03a494607efa1010cde5973167f394150322b36d784eb23305664b8adea0ef12d90c0552a61d726cb1fce83620211f8827c1e4101f0ee0
+  data.tar.gz: cb578b9f45359fd1a93d219761f41ecdb0e0670150be69c731f4d5c1c2695e3ade918e2b5e825701cff380dcaaad6f76c09638628664f3d879f009191e9f9b58

data/README.md

@@ -57,4 +57,16 @@ stateDiagram-v2
 
 At finalization we will call the `btx_user_finalization(struct xprof_common_data *common_data)`
 
-
+# Callbacks Registration and Calling order
+ 
+```
+0 register_callback
+1 call_initialize_component # Cannot Push
+2 call_read_params
+3   stream_begin
+4       call_initialize_processing # Can Push
+5           call_callbacks
+5       call_finalize_processing # Can Push
+6   stream_end
+7 call_finalize_component # Cannot push
+```

data/bin/metababel

@@ -5,19 +5,8 @@ require 'optparse'
 require 'erb'
 require 'metababel'
 require 'fileutils'
-
-def validate_model(yaml)
-  # Stream and event classes must have a 'name' as minimum requirement.
-  raise "Missing 'name' attr in model #{yaml}" unless yaml[:stream_classes].all? do |d|
-                                                        d.key?(:name) && d[:event_classes].all? do |d2|
-                                                          d2.key?(:name)
-                                                        end
-                                                      end
-
-  # Event class name must be unique
-  events = yaml[:stream_classes].flat_map { |sc|  sc[:event_classes] }.map { |e| e[:name] }
-  raise "Duplicated 'event' in model #{yaml}" unless events.length == events.uniq.length
-end
+require 'set'
+require 'ostruct'
 
 class Array
   def join_with_prefix(sep)
@@ -44,19 +33,113 @@ class Hash
   end
 end
 
-EventClassInfo = Struct.new(:name, :args, :body, :index_stream_class, :index_event_class, :default_clock_class,
-                            :args_to_free) do
-  def name_sanitized
-    name.gsub(/[^0-9A-Za-z-]/, '_')
+class Babeltrace2Gen::BTTraceClass
+  def filter_map_event_classes_with_index
+    @stream_classes.map.with_index do |s, index_stream_class|
+      s.event_classes.filter_map.with_index do |e, index_event_class|
+        yield(e, index_stream_class, index_event_class, s.default_clock_class)
+      end
+    end.flatten(1)
   end
 end
 
-StreamClassInfo = Struct.new(:name, :args, :body, :default_clock_class) do
+def sanitize(str)
+  str.gsub(/[^0-9A-Za-z-]/, '_')
+end
+
+class BaseDispatch
   def name_sanitized
-    name.gsub(/[^0-9A-Za-z-]/, '_')
+    sanitize(@name)
+  end
+
+  # https://ruby-doc.org/3.2.2/Hash.html#class-Hash-label-User-Defined+Hash+Keys
+  def ==(other)
+    self.class === other and
+      instance_variables.all? { |s| instance_variable_get(s) == other.instance_variable_get(s) }
+  end
+
+  alias eql? ==
+
+  def hash
+    instance_variables.reduce(0) { |a, b| a ^ instance_variable_get(b).hash }
+  end
+end
+
+class StaticDispatcher < BaseDispatch
+  attr_reader :name, :args, :no_btx_handle
+
+  def initialize(name, args, no_btx_handle: false)
+    @name = name
+    @args = args
+    @no_btx_handle = no_btx_handle
+  end
+end
+
+class DispatchType < BaseDispatch
+  attr_reader :name, :args, :id, :matched_dispatchers
+
+  def initialize(name, args, id, matched_dispatchers)
+    @name = name
+    @args = args
+    @id = id
+    @matched_dispatchers = matched_dispatchers
+  end
+end
+
+class Dispatcher < BaseDispatch
+  attr_reader :event_nane, :event, :name,
+              :index_stream_class, :index_event_class,
+              :default_clock_class,
+              :dispatch_types
+
+  def initialize(event, event_name,
+                 mode,
+                 index_stream_class, index_event_class, default_clock_class)
+    @event = event
+    @event_name = event_name
+    @mode = mode
+    @index_stream_class = index_stream_class
+    @index_event_class = index_event_class
+    @default_clock_class = default_clock_class
+    @dispatch_types = []
+    @name = event.name
+  end
+
+  def body_args
+    @body_args ||= begin
+      arg_variables = {}
+      body = Babeltrace2Gen.context(indent: 1) do
+        if @mode == 'setter'
+          @event.get_setter(event: @event_name, arg_variables: arg_variables)
+        elsif @mode == 'getter'
+          @event.get_getter(event: @event_name, arg_variables: arg_variables)
+        end
+      end
+      [arg_variables, body]
+    end
+  end
+
+  # We preprent an empty new line from the body as a hack, to correct the indentation
+  # Indeeed the <%= body %> will be indented, but we don't don't want it,
+  # in the body string is already indented
+  # But we clean the white space empty line afterward \o/
+  def body
+    "\n" + body_args[1]
+  end
+
+  def args
+    evt_args = []
+    evt_args += [GeneratedArg.new('int64_t', '_timestamp')] if @default_clock_class
+    evt_args += body_args[0].fetch('outputs', [])
+  end
+
+  def args_to_free
+    body_args[0].fetch('outputs_allocated', [])
   end
 end
 
+GeneratedArg = Struct.new(:type, :name)
+
 def erb_render_and_save(vars,
                         basename, out_folder, out_name: nil, prefix: 'btx_')
   template = File.read(File.join(__dir__, "../template/#{basename}.erb"))
@@ -65,202 +148,334 @@ def erb_render_and_save(vars,
   # The regex remove the lines who are not indented
   # Maybe related to `https://github.com/ruby/erb/issues/24`
   str = ERB.new(template, trim_mode: '<>').result_with_hash(vars).gsub(/^ +$\n/, '')
-  File.open(File.join(out_folder, "#{prefix}#{out_name || basename}"), 'w') do |f|
-    f.write(str)
-  end
+  File.write(File.join(out_folder, "#{prefix}#{out_name || basename}"), str)
 end
 
-class Babeltrace2Gen::BTTraceClass
-  def map_event_classes_with_index
-    @stream_classes.map.with_index do |s, index_stream_class|
-      s.event_classes.map.with_index do |e, index_event_class|
-        yield(e, index_stream_class, index_event_class, s.default_clock_class)
-      end
-    end.flatten
-  end
-end
+def parse_argv
+  # Display help if no arguments.
+  ARGV << '-h' if ARGV.empty?
 
-class GeneratedArg < Struct.new(:type, :name)
-end
+  options = {}
+
+  options[:disable_callbaks] = ['on_downstream'].to_set
 
-# We preprent an empty new line from the body as a hack, to correct the indentation
-# Indeeed the <%= body %> will be indented, but we don't don't want it,
-# in the body string is already indented
-# But we clean the white space empty line afterward \o/
-def wrote_event_dispatchers(folder, t)
-  event_name = 'event'
-  event_class_dispatchers = t.map_event_classes_with_index do |e, index_stream_class, index_event_class, default_clock_class|
-    arg_variables = {}
-    body = Babeltrace2Gen.context(indent: 1) do
-      e.get_getter(event: event_name, arg_variables: arg_variables)
+  OptionParser.new do |opts|
+    opts.banner = 'Usage: example.rb [options]'
+
+    opts.on('-h', '--help', 'Prints this help') do
+      puts opts
+      exit
     end
-    EventClassInfo.new(e.name, arg_variables.fetch('outputs', []), body, index_stream_class, index_event_class, default_clock_class,
-                       arg_variables.fetch('outputs_allocated', []))
-  end
 
-  stream_classes_matching_dispatchers = t.stream_classes.map do |s|
-    arg_variables = {}
-    body = ''
-    if s.event_common_context_field_class
-      body = Babeltrace2Gen.context(indent: 1) do
-        s.get_getter(event: event_name, arg_variables: arg_variables)
-      end
+    opts.on('-v', '--version', 'Prints this help') do
+      puts "Ruby: #{RUBY_VERSION}"
+      puts "Metababel: #{Metababel::VERSION}"
+      exit
     end
-    StreamClassInfo.new(s.name, arg_variables.fetch('outputs', []), body, s.default_clock_class)
-  end
 
-  d = { event_class_dispatchers: event_class_dispatchers,
-        stream_classes_matching_dispatchers: stream_classes_matching_dispatchers,
-        event_name: event_name }
+    opts.on('-t', '--component TYPE', '[Mandatory] Node within a trace processing graph.') do |p|
+      options[:component_type] = p
+    end
 
-  erb_render_and_save(d, 'upstream.h', folder)
-  erb_render_and_save(d, 'upstream.c', folder)
-end
+    opts.on('-u', '--upstreams PATH', Array, '[Mandatory] Path to the bt2 YAML files for the upstream model.') do |p|
+      options[:upstreams] = p
+    end
+
+    opts.on('-d', '--downstream PATH', '[Optional] Path to the bt2 YAML file for the downstream model.') do |p|
+      options[:downstream] = p
+    end
+
+    opts.on('-p', '--plugin-name PATH', '[Optional] Name of the bt2 plugin created.') do |p|
+      options[:plugin_name] = p
+    end
+
+    opts.on('-c', '--component-name PATH', '[Optional] Name of the bt2 componant created.') do |p|
+      options[:component_name] = p
+    end
+
+    opts.on('--params PATH', '[Optional] Paht to the bt2 YAML params definition.') do |p|
+      options[:params] = p
+    end
+
+    opts.on('-m', '--matching PATH', '[Optional] Path to bt2 YAML matching-callbacks definitions.') do |p|
+      options[:matching] = p
+    end
+
+    opts.on('-o', '--output FOLDER', '[Optional] Output folder path.') do |p|
+      options[:folder] = p
+    end
+
+    opts.on('-i', '--usr-data-header NAME', '[Optional] User datatypes definitions.') do |p|
+      options[:usr_data_header] = p
+    end
 
-def wrote_creates(folder, t)
-  event_name = 'event'
-  downstream_events = t.map_event_classes_with_index do |e, index_stream_class, index_event_class, default_clock_class|
-    arg_variables = {}
-    body = Babeltrace2Gen.context(indent: 1) do
-      e.get_setter(event: event_name, arg_variables: arg_variables)
+    opts.on('--enable-callbacks NAME', Array, '[Optional] Enable some callbacks type') do |p|
+      options[:disable_callbaks] -= p.to_set
     end
-    EventClassInfo.new(e.name, arg_variables.fetch('outputs', []), "\n" + body, index_stream_class, index_event_class,
-                       default_clock_class)
+
+  end.parse!
+
+  raise OptionParser::MissingArgument if options[:component_type].nil?
+
+  options[:plugin_name] ||= "metababel_#{options[:component_type].downcase}"
+  options[:component_name] ||= 'btx'
+
+  options
+end
+
+def get_dispatch_type(em, default_clock_class, context)
+  dispatchers = em.domain ? OpenStruct.new(context).instance_eval(em.domain) : context['all']
+  raise "Nil or empty event set for '#{em.set_id}'." unless dispatchers.is_a?(Set)
+
+  matched_dispatchers, signatures = dispatchers.filter_map do |dispatcher|
+    extracted_args = dispatcher.event.match?(em)
+    [dispatcher, extracted_args] if extracted_args
+  end.transpose
+
+  if !matched_dispatchers || matched_dispatchers.empty?
+    raise "No event matched '#{em.set_id}', at least one matching event required."
   end
 
-  body_declarator_classes = "\n" + Babeltrace2Gen.context(indent: 1) do
-    t.get_declarator(variable: 'trace_class', self_component: 'self_component')
+  # Verify the uniqueness of signatures.
+  # Note that `s.type` takes into account the `cast_type`
+  #   (see TestMatchingConflictingSignatures for more details)
+  unique_signatures = signatures.uniq
+  unless unique_signatures.size == 1
+    signatures_str = unique_signatures.map { |s| "(#{s.map(&:type).join(', ')})" }.join(', ')
+    raise "Conflicting signatures for '#{em.set_id}', found #{unique_signatures.size} signatures, only one allowed: '#{signatures_str}'"
   end
 
-  d = { body_declarator_classes: body_declarator_classes,
-        downstream_events: downstream_events,
-        stream_classes: t.stream_classes,
-        event_name: event_name }
+  # Modify the dispatcher to add the new dispatchType
+  name = em.set_id
+  dispatch_type_args = []
+  dispatch_type_args += [GeneratedArg.new('int64_t', '_timestamp')] if default_clock_class
+  dispatch_type_args += [GeneratedArg.new('const char *', '_event_class_name')]
+  dispatch_type_args += signatures.pop
+
+  dispatch_type = DispatchType.new(
+    name, dispatch_type_args, "matching_#{sanitize(name)}", matched_dispatchers
+  )
+
+  # Update context for further events filtering.
+  context[dispatch_type.name] = dispatch_type.matched_dispatchers.to_set
+
+  # Exclude unnecessary rendering.
+  return false unless em.register
 
-  erb_render_and_save(d, 'downstream.h', folder)
-  erb_render_and_save(d, 'downstream.c', folder)
+  matched_dispatchers.each { |dispatcher| dispatcher.dispatch_types << dispatch_type }
+
+  dispatch_type
 end
 
-def wrote_component(options, d, folder)
-  component_dispatchers = [EventClassInfo.new('initialize_usr_data',
-                                              [GeneratedArg.new('void **', 'usr_data_p')]),
-                           EventClassInfo.new('finalize_usr_data',
-                                              [GeneratedArg.new('void *', 'usr_data')]),
-                           EventClassInfo.new('read_params',
-                                              [GeneratedArg.new('void *', 'usr_data'),
-                                               GeneratedArg.new('btx_params_t *', 'usr_params')])]
-
-  if options[:component_type] == 'SOURCE'
-    component_dispatchers << EventClassInfo.new('push_usr_messages',
-                                                [GeneratedArg.new('void *', 'usr_data'),
-                                                 GeneratedArg.new('btx_source_status_t*', 'status')])
-  end
+def validate_model(yaml)
+  # Stream and event classes must have a 'name' as minimum requirement.
+  raise "Missing 'name' attr in model #{yaml}" unless yaml[:stream_classes].all? do |d|
+                                                        d.key?(:name) && d[:event_classes].all? do |d2|
+                                                          d2.key?(:name)
+                                                        end
+                                                      end
 
-  d2 = { component_dispatchers: component_dispatchers,
-         event_name: 'dummy_event' }
+  # Event class name must be unique
+  events = yaml[:stream_classes].flat_map { |sc| sc[:event_classes] }.map { |e| e[:name] }
+  raise "Duplicated 'event' in model #{yaml}" unless events.length == events.uniq.length
 
-  erb_render_and_save(d2.update(d).update(options: options), 'component.h', folder)
-  erb_render_and_save(d2.update(d).update(options: options), 'component.c', folder)
+  yaml
 end
 
-# Display help if no arguments.
-ARGV << '-h' if ARGV.empty?
+def load_models(models)
+  yaml = [models].flatten
+                 .map { |f| YAML.load_file(f) }
+                 .reduce({}) { |s, y| s.deep_merge(y) { |_key, old, new| old + new } }
+  validate_model(yaml)
+end
 
-options = {}
-OptionParser.new do |opts|
-  opts.banner = 'Usage: example.rb [options]'
+class ContextBuilder
+  attr_accessor :cli_options
 
-  opts.on('-h', '--help', 'Prints this help') do
-    puts opts
-    exit
+  def initialize
+    @cli_options = parse_argv
   end
 
-  opts.on('-v', '--version', 'Prints this help') do
-    puts "Ruby: #{RUBY_VERSION}"
-    puts "Metababel: #{Metababel::VERSION}"
-    exit
+  def base_folder
+    @base_folder ||= begin
+      f = @cli_options[:folder] || "#{@cli_options[:component_type]}.#{@cli_options[:plugin_name]}.#{@cli_options[:component_name]}"
+      FileUtils.mkdir_p(f)
+      f
+    end
   end
 
-  opts.on('-t', '--component TYPE', '[Mandatory] Node within a trace processing graph.') do |p|
-    options[:component_type] = p
+  def folder
+    @folder ||= begin
+      f = "#{base_folder}/metababel"
+      FileUtils.mkdir_p(f)
+      f
+    end
   end
 
-  opts.on('-u', '--upstreams PATH', Array, '[Mandatory] Path to the bt2 yaml file.') do |p|
-    options[:upstreams] = p
+  def options
+    { options: @cli_options }
   end
 
-  opts.on('-d', '--downstream PATH', '[Optional] Path to the bt2 yaml file.') do |p|
-    options[:downstream] = p
+  def params
+    @params ||= if @cli_options.key?(:params)
+                  y = YAML.load_file(@cli_options[:params])
+                  c = Babeltrace2Gen::BTValueCLass.from_h(y)
+                  body = Babeltrace2Gen.context(indent: 1) do
+                    c.get('_usr_params', '_params')
+                  end
+                  { params_declaration: c.get_struct_definition('_params'),
+                    params_definition: body }
+                else
+                  { params_declaration: nil, params_definition: nil }
+                end
   end
 
-  opts.on('-p', '--plugin-name PATH', '[Optional] Name of the bt2 plugin created.') do |p|
-    options[:plugin_name] = p
+  def trace_matcher
+    @trace_matcher ||= if @cli_options.key?(:matching)
+                         data = YAML.load_file(@cli_options[:matching])
+                         data[:match] = true
+                         Babeltrace2Gen::BTTraceClass.from_h(nil, data)
+                       else
+                         Babeltrace2Gen::BTTraceClass.new(parent: nil, stream_classes: [])
+                       end
   end
 
-  opts.on('-c', '--component-name PATH', '[Optional] Name of the bt2 componant created.') do |p|
-    options[:component_name] = p
-  end
+  def callback_types
+    @callback_types ||= begin
+      callback_types = ['generic']
+      if @cli_options.key?(:matching)
+        event_classes = trace_matcher.stream_classes.map(&:event_classes).flatten(1).filter do |em|
+          raise "Key ':set_id' required for matching events." unless em.set_id
 
-  opts.on('--params PATH', '[Optional] Name of YAML params definition.') do |p|
-    options[:params] = p
-  end
+          em.register
+        end
+        callback_types += event_classes.map { |em| "matching_#{sanitize(em.set_id)}" }
+      end
 
-  opts.on('-o', '--output FOLDER', '[Optional] Output folder path.') do |p|
-    options[:folder] = p
+      static_callbacks = [StaticDispatcher.new('initialize_component',
+                                               [GeneratedArg.new('void **', 'usr_data_p')],
+                                               no_btx_handle: true),
+                          StaticDispatcher.new('finalize_component',
+                                               [GeneratedArg.new('void *', 'usr_data')],
+                                               no_btx_handle: true),
+                          StaticDispatcher.new('read_params',
+                                               [GeneratedArg.new('void *', 'usr_data'),
+                                                GeneratedArg.new('btx_params_t *', 'usr_params')],
+                                               no_btx_handle: true)]
+      # Usefull to push message
+      if %w[SOURCE FILTER].include?(@cli_options[:component_type])
+        static_callbacks += [StaticDispatcher.new('initialize_processing',
+                                                  [GeneratedArg.new('void *', 'usr_data_p')]),
+                             StaticDispatcher.new('finalize_processing',
+                                                  [GeneratedArg.new('void *', 'usr_data')])]
+      end
+
+      if %w[SOURCE].include?(@cli_options[:component_type])
+        static_callbacks << StaticDispatcher.new('push_usr_messages',
+                                                 [GeneratedArg.new('void *', 'usr_data'),
+                                                  GeneratedArg.new('btx_source_status_t*', 'status')])
+
+      end
+      { callback_types: callback_types,
+        static_callback_types: static_callbacks }
+    end
   end
 
-  opts.on('-i', '--usr-data-header NAME', '[Optional] User datatypes definitions.') do |p|
-    options[:usr_data_header] = p
+  def downstream
+    @downstream ||= begin
+      raise 'Missing downstream model' unless @cli_options[:downstream]
+
+      y = load_models(@cli_options[:downstream])
+      t = Babeltrace2Gen::BTTraceClass.from_h(nil, y)
+
+      event_name = '_event'
+      downstream_events = t.filter_map_event_classes_with_index do |e, index_stream_class, index_event_class, default_clock_class|
+        Dispatcher.new(e, event_name, 'setter', index_stream_class, index_event_class, default_clock_class)
+      end
+
+      body_declarator_classes = "\n" + Babeltrace2Gen.context(indent: 1) do
+        t.get_declarator(variable: '_trace_class', self_component: '_self_component')
+      end
+
+      { body_declarator_classes: body_declarator_classes,
+        downstream_events: downstream_events,
+        stream_classes: t.stream_classes,
+        event_name: event_name }
+    end
   end
-end.parse!
 
-raise OptionParser::MissingArgument if options[:component_type].nil?
+  def upstream
+    @upstream ||= begin
+      raise 'Missing upstreams models' unless @cli_options[:upstreams]
 
-options[:plugin_name] ||= "metababel_#{options[:component_type].downcase}"
-options[:component_name] ||= 'btx'
+      y = load_models(@cli_options[:upstreams])
+      t = Babeltrace2Gen::BTTraceClass.from_h(nil, y)
 
-# Babeltrace can be extended by plugins, which provide one or more component classes.
-base_folder = options[:folder] || "#{options[:component_type]}.#{options[:plugin_name]}.#{options[:component_name]}"
-folder = "#{base_folder}/metababel"
-FileUtils.mkdir_p(folder)
-
-d = { options: options }
-
-d[:params_declaration] = ''
-d[:params_definition] = ''
-if options.key?(:params)
-  y = YAML.load_file(options[:params])
-  c = Babeltrace2Gen::BTValueCLass.from_h(y)
-  body = Babeltrace2Gen.context(indent: 1) do
-    c.get('usr_params', 'params')
+      event_name = '_event'
+      dispatchers, automatic_dispatch_types = t.filter_map_event_classes_with_index do |e, index_stream_class, index_event_class, default_clock_class|
+        dispatcher =  Dispatcher.new(e, event_name, 'getter', index_stream_class, index_event_class,
+                                     default_clock_class)
+        dispatch_type = DispatchType.new(e.name, dispatcher.args, 'generic', [dispatcher])
+        dispatcher.dispatch_types << dispatch_type
+
+        [dispatcher, dispatch_type]
+      end.transpose
+
+      context = { 'all' => dispatchers.to_set }
+      matching_dispatch_types = trace_matcher.filter_map_event_classes_with_index do |em, _, _, default_clock_class|
+        # We mutate context across iterations.
+        get_dispatch_type(em, default_clock_class, context)
+      end
+
+      { dispatchers: dispatchers,
+        dispatch_types: automatic_dispatch_types + matching_dispatch_types,
+        event_name: event_name }
+    end
+  end
+
+  def get_context(list_symbols)
+    d = {}
+    d.update(options) if list_symbols.include?('options')
+    d.update(params) if list_symbols.include?('params')
+    d.update(callback_types) if list_symbols.include?('callback_types')
+    d.update(static_callback_types) if list_symbols.include?('static_callback_types')
+    d.update(downstream) if list_symbols.include?('downstream')
+    d.update(upstream) if list_symbols.include?('upstream')
+    d
   end
-  d[:params_declaration] = c.get_struct_definition('params')
-  d[:params_definition] = body
-else
-  d[:params_declaration] = 'char _dummy;'
 end
 
-erb_render_and_save(d, "#{options[:component_type].downcase}.c", base_folder, out_name: 'main.c')
-erb_render_and_save({ options: options }, 'metababel.h', folder, prefix: '')
+def wrote_upstream(cb)
+  erb_render_and_save(cb.get_context(%w[upstream]), 'upstream.h', cb.folder)
+  erb_render_and_save(cb.get_context(%w[upstream]), 'upstream.c', cb.folder)
+end
 
-wrote_component(options, d, folder)
-if %w[SOURCE FILTER].include?(options[:component_type])
-  raise 'Missing downstream model' unless options[:downstream]
+def wrote_downstream(cb)
+  erb_render_and_save(cb.get_context(%w[downstream options]), 'downstream.h', cb.folder)
+  erb_render_and_save(cb.get_context(%w[downstream options]), 'downstream.c', cb.folder)
+end
 
-  y = YAML.load_file(options[:downstream])
-  validate_model(y)
-  t = Babeltrace2Gen::BTTraceClass.from_h(nil, y)
-  wrote_creates(folder, t)
+def wrote_component(cb)
+  erb_render_and_save(cb.get_context(%w[options params callback_types]), 'component.h',
+                      cb.folder)
+  erb_render_and_save(cb.get_context(%w[options params callback_types]), 'component.c',
+                      cb.folder)
 end
 
-if %w[FILTER SINK].include?(options[:component_type])
-  raise 'Missing upstream models' unless options[:upstreams]
+def wrote_main(cb)
+  erb_render_and_save(cb.get_context(%w[params options]), "#{cb.cli_options[:component_type].downcase}.c",
+                      cb.base_folder, out_name: 'main.c')
+end
 
-  y = options[:upstreams].reduce({}) do |y, upstream|
-    # Need to specialize for merging arrays
-    y.deep_merge(YAML.load_file(upstream)) { |_key, old, new| old + new }
-  end
-  validate_model(y)
-  t = Babeltrace2Gen::BTTraceClass.from_h(nil, y)
-  wrote_event_dispatchers(folder, t)
+def wrote_header(cb)
+  erb_render_and_save(cb.get_context(%w[options]), 'metababel.h',
+                      cb.folder, prefix: '')
 end
+
+# Babeltrace can be extended by plugins, which provide one or more component classes.
+context_builder = ContextBuilder.new
+wrote_header(context_builder)
+wrote_main(context_builder)
+wrote_component(context_builder)
+wrote_downstream(context_builder) if %w[SOURCE FILTER].include?(context_builder.cli_options[:component_type])
+wrote_upstream(context_builder) if %w[FILTER SINK].include?(context_builder.cli_options[:component_type])