openc3 5.0.6

data/lib/openc3/models/gem_model.rb

@@ -0,0 +1,137 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'open-uri'
+require 'nokogiri'
+require 'httpclient'
+require 'rubygems'
+require 'rubygems/uninstaller'
+require 'tempfile'
+require 'openc3/utilities/s3'
+require 'openc3/utilities/process_manager'
+require 'openc3/api/api'
+
+module OpenC3
+  # This class acts like a Model but doesn't inherit from Model because it doesn't
+  # actual interact with the Store (Redis). Instead we implement names, get, put
+  # and destroy to allow interaction with gem files from the PluginModel and
+  # the GemsController.
+  class GemModel
+    extend Api
+
+    @@bucket_initialized = false
+
+    def self.names
+      rubys3_client = initialize_bucket()
+      gems = []
+      rubys3_client.list_objects(bucket: 'gems').contents.each do |object|
+        gems << object.key
+      end
+      gems
+    end
+
+    def self.get(dir, name)
+      rubys3_client = initialize_bucket()
+      path = File.join(dir, name)
+      rubys3_client.get_object(bucket: 'gems', key: name, response_target: path)
+      return path
+    end
+
+    def self.put(gem_file_path, gem_install: true, scope:)
+      rubys3_client = initialize_bucket()
+      if File.file?(gem_file_path)
+        gem_filename = File.basename(gem_file_path)
+        Logger.info "Installing gem: #{gem_filename}"
+        File.open(gem_file_path, 'rb') do |file|
+          rubys3_client.put_object(bucket: 'gems', key: gem_filename, body: file)
+        end
+        if gem_install
+          result = OpenC3::ProcessManager.instance.spawn(["ruby", "/openc3/bin/openc3cli", "geminstall", gem_filename], "gem_install", gem_filename, Time.now + 3600.0, scope: scope)
+          return result
+        end
+      else
+        message = "Gem file #{gem_file_path} does not exist!"
+        Logger.error message
+        raise message
+      end
+      return nil
+    end
+
+    def self.install(name_or_path, scope:)
+      temp_dir = Dir.mktmpdir
+      begin
+        if File.exist?(name_or_path)
+          gem_file_path = name_or_path
+        else
+          gem_file_path = get(temp_dir, name_or_path)
+        end
+        begin
+          rubygems_url = get_setting('rubygems_url', scope: scope)
+        rescue
+          # If Redis isn't running try the ENV, then simply rubygems.org
+          rubygems_url = ENV['RUBYGEMS_URL']
+          rubygems_url ||= 'https://rubygems.org'
+        end
+        Gem.sources = [rubygems_url] if rubygems_url
+        Gem.done_installing_hooks.clear
+        Gem.install(gem_file_path, "> 0.pre", :build_args => ['--no-document'], :prerelease => true)
+      rescue => err
+        message = "Gem file #{gem_file_path} error installing to /gems\n#{err.formatted}"
+        Logger.error message
+      ensure
+        FileUtils.remove_entry(temp_dir) if temp_dir and File.exist?(temp_dir)
+      end
+    end
+
+    def self.destroy(name)
+      rubys3_client = initialize_bucket()
+      Logger.info "Removing gem: #{name}"
+      rubys3_client.delete_object(bucket: 'gems', key: name)
+      gem_name, version = self.extract_name_and_version(name)
+      begin
+        Gem::Uninstaller.new(gem_name, {:version => version, :force => true}).uninstall
+      rescue => err
+        message = "Gem file #{name} error uninstalling\n#{err.formatted}"
+        Logger.error message
+      end
+    end
+
+    def self.extract_name_and_version(name)
+      split_name = name.split('-')
+      gem_name = split_name[0..-2].join('-')
+      version = split_name[-1]
+      return gem_name, version
+    end
+
+    # private
+
+    def self.initialize_bucket
+      rubys3_client = Aws::S3::Client.new
+      unless @@bucket_initialized
+        begin
+          rubys3_client.head_bucket(bucket: 'gems')
+        rescue Aws::S3::Errors::NotFound
+          rubys3_client.create_bucket(bucket: 'gems')
+        end
+        @@bucket_initialized = true
+      end
+      return rubys3_client
+    end
+  end
+end

data/lib/openc3/models/info_model.rb

@@ -0,0 +1,31 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/utilities/store'
+
+module OpenC3
+  class InfoModel
+
+    # @return Hash information and statistics about the redis server
+    def self.get()
+      return [Store.info(), EphemeralStore.info]
+    end
+
+  end
+end

data/lib/openc3/models/interface_model.rb

@@ -0,0 +1,281 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/models/model'
+require 'openc3/models/microservice_model'
+
+module OpenC3
+  class InterfaceModel < Model
+    INTERFACES_PRIMARY_KEY = 'openc3_interfaces'
+    ROUTERS_PRIMARY_KEY = 'openc3_routers'
+
+    attr_accessor :config_params
+    attr_accessor :target_names
+    attr_accessor :connect_on_startup
+    attr_accessor :auto_reconnect
+    attr_accessor :reconnect_delay
+    attr_accessor :disable_disconnect
+    attr_accessor :options
+    attr_accessor :protocols
+    attr_accessor :interfaces
+    attr_accessor :log
+    attr_accessor :log_raw
+    attr_accessor :needs_dependencies
+
+    # NOTE: The following three class methods are used by the ModelController
+    # and are reimplemented to enable various Model class methods to work
+    def self.get(name:, scope:)
+      super("#{scope}__#{_get_key}", name: name)
+    end
+
+    def self.names(scope:)
+      super("#{scope}__#{_get_key}")
+    end
+
+    def self.all(scope:)
+      super("#{scope}__#{_get_key}")
+    end
+    # END NOTE
+
+    # Called by the PluginModel to allow this class to validate it's top-level keyword: "INTERFACE"
+    # Interface/Router specific keywords are handled by the instance method "handle_config"
+    # NOTE: See RouterModel for the router method implementation
+    def self.handle_config(parser, keyword, parameters, plugin: nil, needs_dependencies: false, scope:)
+      case keyword
+      when 'INTERFACE'
+        parser.verify_num_parameters(2, nil, "INTERFACE <Name> <Filename> <Specific Parameters>")
+        return self.new(name: parameters[0].upcase, config_params: parameters[1..-1], plugin: plugin, needs_dependencies: needs_dependencies, scope: scope)
+      else
+        raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Interface: #{keyword} #{parameters.join(" ")}")
+      end
+    end
+
+    # Helper method to return the correct type based on class name
+    def self._get_type
+      self.name.to_s.split("Model")[0].upcase.split("::")[-1]
+    end
+
+    # Helper method to return the correct primary key based on class name
+    def self._get_key
+      type = _get_type
+      case type
+      when 'INTERFACE'
+        INTERFACES_PRIMARY_KEY
+      when 'ROUTER'
+        ROUTERS_PRIMARY_KEY
+      else
+        raise "Unknown type #{type} from class #{self.name}"
+      end
+    end
+
+    def initialize(
+      name:,
+      config_params: [],
+      target_names: [],
+      connect_on_startup: true,
+      auto_reconnect: true,
+      reconnect_delay: 5.0,
+      disable_disconnect: false,
+      options: [],
+      protocols: [],
+      log: true,
+      log_raw: false,
+      updated_at: nil,
+      plugin: nil,
+      needs_dependencies: false,
+      scope:
+    )
+      if self.class._get_type == 'INTERFACE'
+        super("#{scope}__#{INTERFACES_PRIMARY_KEY}", name: name, updated_at: updated_at, plugin: plugin, scope: scope)
+      else
+        super("#{scope}__#{ROUTERS_PRIMARY_KEY}", name: name, updated_at: updated_at, plugin: plugin, scope: scope)
+      end
+      @config_params = config_params
+      @target_names = target_names
+      @connect_on_startup = connect_on_startup
+      @auto_reconnect = auto_reconnect
+      @reconnect_delay = reconnect_delay
+      @disable_disconnect = disable_disconnect
+      @options = options
+      @protocols = protocols
+      @log = log
+      @log_raw = log_raw
+      @needs_dependencies = needs_dependencies
+    end
+
+    # Called by InterfaceMicroservice to instantiate the Interface defined
+    # by the model configuration. Must be called after get_model which
+    # calls from_json to instantiate the class and populate the attributes.
+    def build
+      klass = OpenC3.require_class(@config_params[0])
+      if @config_params.length > 1
+        interface_or_router = klass.new(*@config_params[1..-1])
+      else
+        interface_or_router = klass.new
+      end
+      interface_or_router.target_names = @target_names.dup
+      interface_or_router.connect_on_startup = @connect_on_startup
+      interface_or_router.auto_reconnect = @auto_reconnect
+      interface_or_router.reconnect_delay = @reconnect_delay
+      interface_or_router.disable_disconnect = @disable_disconnect
+      @options.each do |option|
+        interface_or_router.set_option(option[0], option[1..-1])
+      end
+      @protocols.each do |protocol|
+        klass = OpenC3.require_class(protocol[1])
+        interface_or_router.add_protocol(klass, protocol[2..-1], protocol[0].upcase.intern)
+      end
+      interface_or_router
+    end
+
+    def as_json(*a)
+      {
+        'name' => @name,
+        'config_params' => @config_params,
+        'target_names' => @target_names,
+        'connect_on_startup' => @connect_on_startup,
+        'auto_reconnect' => @auto_reconnect,
+        'reconnect_delay' => @reconnect_delay,
+        'disable_disconnect' => @disable_disconnect,
+        'options' => @options,
+        'protocols' => @protocols,
+        'log' => @log,
+        'log_raw' => @log_raw,
+        'plugin' => @plugin,
+        'needs_dependencies' => @needs_dependencies,
+        'updated_at' => @updated_at
+      }
+    end
+
+    # TODO: Not currently used but may be used by a XTCE or other format to OpenC3 conversion
+    def as_config
+      result = "#{self.class._get_type} #{@name} #{@config_params.join(' ')}\n"
+      @target_names.each do |target_name|
+        result << "  MAP_TARGET #{target_name}\n"
+      end
+      result << "  DONT_CONNECT\n" unless @connect_on_startup
+      result << "  DONT_RECONNECT\n" unless @auto_reconnect
+      result << "  RECONNECT_DELAY #{@reconnect_delay}\n"
+      result << "  DISABLE_DISCONNECT\n" if @disable_disconnect
+      @options.each do |option|
+        result << "  OPTION #{option.join(' ')}\n"
+      end
+      @protocols.each do |protocol|
+        result << "  PROTOCOL #{protocol.join(' ')}\n"
+      end
+      result << "  DONT_LOG" unless @log
+      result << "  LOG_RAW" if @log_raw
+      result
+    end
+
+    # Handles Interface/Router specific configuration keywords
+    def handle_config(parser, keyword, parameters)
+      case keyword
+      when 'MAP_TARGET'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Target Name>")
+        @target_names << parameters[0].upcase
+
+      when 'DONT_CONNECT'
+        parser.verify_num_parameters(0, 0, "#{keyword}")
+        @connect_on_startup = false
+
+      when 'DONT_RECONNECT'
+        parser.verify_num_parameters(0, 0, "#{keyword}")
+        @auto_reconnect = false
+
+      when 'RECONNECT_DELAY'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Delay in Seconds>")
+        @reconnect_delay = Float(parameters[0])
+
+      when 'DISABLE_DISCONNECT'
+        parser.verify_num_parameters(0, 0, "#{keyword}")
+        @disable_disconnect = true
+
+      when 'OPTION'
+        parser.verify_num_parameters(2, nil, "#{keyword} <Option Name> <Option Value 1> <Option Value 2 (optional)> <etc>")
+        @options << parameters.dup
+
+      when 'PROTOCOL'
+        usage = "#{keyword} <READ WRITE READ_WRITE> <protocol filename or classname> <Protocol specific parameters>"
+        parser.verify_num_parameters(2, nil, usage)
+        unless %w(READ WRITE READ_WRITE).include? parameters[0].upcase
+          raise parser.error("Invalid protocol type: #{parameters[0]}", usage)
+        end
+
+        @protocols << parameters.dup
+
+      when 'DONT_LOG'
+        parser.verify_num_parameters(0, 0, "#{keyword}")
+        @log = false
+
+      when 'LOG_RAW'
+        parser.verify_num_parameters(0, 0, "#{keyword}")
+        @log_raw = true
+
+      else
+        raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Interface/Router: #{keyword} #{parameters.join(" ")}")
+
+      end
+
+      return nil
+    end
+
+    # Creates a MicroserviceModel to deploy the Interface/Router
+    def deploy(gem_path, variables, validate_only: false)
+      type = self.class._get_type
+      microservice_name = "#{@scope}__#{type}__#{@name}"
+      microservice = MicroserviceModel.new(
+        name: microservice_name,
+        work_dir: '/openc3/lib/openc3/microservices',
+        cmd: ["ruby", "#{type.downcase}_microservice.rb", microservice_name],
+        target_names: @target_names,
+        plugin: @plugin,
+        needs_dependencies: @needs_dependencies,
+        scope: @scope
+      )
+      unless validate_only
+        microservice.create
+        microservice.deploy(gem_path, variables)
+        ConfigTopic.write({ kind: 'created', type: type.downcase, name: @name, plugin: @plugin }, scope: @scope)
+        Logger.info "Configured #{type.downcase} microservice #{microservice_name}"
+      end
+      microservice
+    end
+
+    # Looks up the deployed MicroserviceModel and destroy the microservice model
+    # should should trigger the operator to kill the microservice that in turn
+    # will destroy the InterfaceStatusModel when a stop is called.
+    def undeploy
+      type = self.class._get_type
+      name = "#{@scope}__#{type}__#{@name}"
+      model = MicroserviceModel.get_model(name: name, scope: @scope)
+      if model
+        model.destroy
+        ConfigTopic.write({ kind: 'deleted', type: type.downcase, name: @name, plugin: @plugin }, scope: @scope)
+      end
+
+      if type == 'INTERFACE'
+        status_model = InterfaceStatusModel.get_model(name: @name, scope: @scope)
+      else
+        status_model = RouterStatusModel.get_model(name: @name, scope: @scope)
+      end
+      status_model.destroy if status_model
+    end
+  end
+end

data/lib/openc3/models/interface_status_model.rb

@@ -0,0 +1,117 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/models/model'
+
+module OpenC3
+  # Stores the status about an interface. This class also implements logic
+  # to handle status for a router since the functionality is identical
+  # (only difference is the Redis key used).
+  class InterfaceStatusModel < EphemeralModel
+    INTERFACES_PRIMARY_KEY = 'openc3_interface_status'
+    ROUTERS_PRIMARY_KEY = 'openc3_router_status'
+
+    attr_accessor :state
+    attr_accessor :clients
+    attr_accessor :txsize
+    attr_accessor :rxsize
+    attr_accessor :txbytes
+    attr_accessor :rxbytes
+    attr_accessor :txcnt
+    attr_accessor :rxcnt
+
+    # NOTE: The following three class methods are used by the ModelController
+    # and are reimplemented to enable various Model class methods to work
+    def self.get(name:, scope:)
+      super("#{scope}__#{_get_key}", name: name)
+    end
+
+    def self.names(scope:)
+      super("#{scope}__#{_get_key}")
+    end
+
+    def self.all(scope:)
+      super("#{scope}__#{_get_key}")
+    end
+    # END NOTE
+
+    # Helper method to return the correct type based on class name
+    def self._get_type
+      self.name.to_s.split("Model")[0].upcase.split("::")[-1]
+    end
+
+    # Helper method to return the correct primary key based on class name
+    def self._get_key
+      type = _get_type
+      case type
+      when 'INTERFACESTATUS'
+        INTERFACES_PRIMARY_KEY
+      when 'ROUTERSTATUS'
+        ROUTERS_PRIMARY_KEY
+      else
+        raise "Unknown type #{type} from class #{self.name}"
+      end
+    end
+
+    def initialize(
+      name:,
+      state:,
+      clients: 0,
+      txsize: 0,
+      rxsize: 0,
+      txbytes: 0,
+      rxbytes: 0,
+      txcnt: 0,
+      rxcnt: 0,
+      updated_at: nil,
+      plugin: nil,
+      scope:
+    )
+      if self.class._get_type == 'INTERFACESTATUS'
+        super("#{scope}__#{INTERFACES_PRIMARY_KEY}", name: name, updated_at: updated_at, plugin: plugin, scope: scope)
+      else
+        super("#{scope}__#{ROUTERS_PRIMARY_KEY}", name: name, updated_at: updated_at, plugin: plugin, scope: scope)
+      end
+      @state = state
+      @clients = clients
+      @txsize = txsize
+      @rxsize = rxsize
+      @txbytes = txbytes
+      @rxbytes = rxbytes
+      @txcnt = txcnt
+      @rxcnt = rxcnt
+    end
+
+    def as_json(*a)
+      {
+        'name' => @name,
+        'state' => @state,
+        'clients' => @clients,
+        'txsize' => @txsize,
+        'rxsize' => @rxsize,
+        'txbytes' => @txbytes,
+        'rxbytes' => @rxbytes,
+        'txcnt' => @txcnt,
+        'rxcnt' => @rxcnt,
+        'plugin' => @plugin,
+        'updated_at' => @updated_at
+      }
+    end
+  end
+end

data/lib/openc3/models/metadata_model.rb

@@ -0,0 +1,139 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+# https://www.rubydoc.info/gems/redis/Redis/Commands/SortedSets
+
+require 'openc3/models/sorted_model'
+
+module OpenC3
+  class MetadataModel < SortedModel
+    METADATA_TYPE = 'metadata'.freeze
+    PRIMARY_KEY = '__METADATA'.freeze
+
+    def self.pk(scope)
+      "#{scope}#{PRIMARY_KEY}"
+    end
+
+    attr_reader :color, :metadata, :constraints, :type
+
+    # @param [Integer] start - Time metadata is active in seconds from Epoch
+    # @param [String] color - The event color
+    # @param [Hash] metadata - Hash of metadata values
+    # @param [Hash] constraints - Constraints to apply to the metadata
+    # @param [String] scope - OpenC3 scope to track event to
+    def initialize(
+      scope:,
+      start:,
+      color: nil,
+      metadata:,
+      constraints: nil,
+      type: METADATA_TYPE,
+      updated_at: 0
+    )
+      super(start: start, scope: scope, updated_at: updated_at)
+      @start = start
+      @color = color
+      @metadata = metadata
+      @constraints = constraints if constraints
+      @type = type # For the as_json, from_json round trip
+    end
+
+    # Validates the instance variables: @start, @color, @metadata
+    def validate(update: false)
+      validate_start(update: update)
+      validate_color()
+      validate_metadata()
+      validate_constraints() if @constraints
+    end
+
+    def validate_color()
+      if @color.nil?
+        @color = '#%06x' % (rand * 0xffffff)
+      end
+      unless @color =~ /(#*)([0-9,a-f,A-f]{6})/
+        raise SortedInputError.new "invalid color, must be in hex format, e.g. #FF0000"
+      end
+      @color = "##{@color}" unless @color.start_with?('#')
+    end
+
+    def validate_metadata()
+      unless @metadata.is_a?(Hash)
+        raise SortedInputError.new "Metadata must be a hash/object: #{@metadata}"
+      end
+      # Convert keys to strings. This isn't quite as efficient as symbols
+      # but we store as JSON which is all strings and it makes comparisons easier.
+      @metadata = @metadata.transform_keys(&:to_s)
+    end
+
+    def validate_constraints()
+      unless @constraints.is_a?(Hash)
+        raise SortedInputError.new "Constraints must be a hash/object: #{@constraints}"
+      end
+      # Convert keys to strings. This isn't quite as efficient as symbols
+      # but we store as JSON which is all strings and it makes comparisons easier.
+      @constraints = @constraints.transform_keys(&:to_s)
+      unless (@constraints.keys - @metadata.keys).empty?
+        raise SortedInputError.new "Constraints keys must be subset of metadata: #{@constraints.keys} subset #{@metadata.keys}"
+      end
+      @constraints.each do |key, constraint|
+        unless constraint.include?(@metadata[key])
+          raise SortedInputError.new "Constraint violation! key:#{key} value:#{@metadata[key]} constraint:#{constraint}"
+        end
+      end
+    end
+
+    # Update the Redis hash at primary_key based on the initial passed start
+    # The member is set to the JSON generated via calling as_json
+    def create(update: false)
+      validate(update: update)
+      @updated_at = Time.now.to_nsec_from_epoch
+      MetadataModel.destroy(scope: @scope, start: update) if update
+      Store.zadd(@primary_key, @start, JSON.generate(as_json(:allow_nan => true)))
+      if update
+        notify(kind: 'updated')
+      else
+        notify(kind: 'created')
+      end
+    end
+
+    # Update the model. All arguments are optional, only those set will be updated.
+    def update(start: nil, color: nil, metadata: nil, constraints: nil)
+      orig_start = @start
+      @start = start if start
+      @color = color if color
+      @metadata = metadata if metadata
+      @constraints = constraints if constraints
+      create(update: orig_start)
+    end
+
+    # @return [Hash] generated from the MetadataModel
+    def as_json(*a)
+      {
+        'scope' => @scope,
+        'start' => @start,
+        'color' => @color,
+        'metadata' => @metadata.as_json(*a),
+        'constraints' => @constraints,
+        'type' => METADATA_TYPE,
+        'updated_at' => @updated_at,
+      }
+    end
+    alias to_s as_json
+  end
+end