scenario_import.rb 9.1KB

    require 'ostruct' # This is a helper class for managing Scenario imports, used by the ScenarioImportsController. This class behaves much # like a normal ActiveRecord object, with validations and callbacks. However, it is never persisted to the database. class ScenarioImport include ActiveModel::Model include ActiveModel::Callbacks include ActiveModel::Validations::Callbacks DANGEROUS_AGENT_TYPES = %w[Agents::ShellCommandAgent] URL_REGEX = /\Ahttps?:\/\//i attr_accessor :file, :url, :data, :do_import, :merges attr_reader :user before_validation :parse_file before_validation :fetch_url validate :validate_presence_of_file_url_or_data validates_format_of :url, :with => URL_REGEX, :allow_nil => true, :allow_blank => true, :message => "appears to be invalid" validate :validate_data validate :generate_diff def step_one? data.blank? end def step_two? data.present? end def set_user(user) @user = user end def existing_scenario @existing_scenario ||= user.scenarios.find_by(:guid => parsed_data["guid"]) end def dangerous? (parsed_data['agents'] || []).any? { |agent| DANGEROUS_AGENT_TYPES.include?(agent['type']) } end def parsed_data @parsed_data ||= (data && JSON.parse(data) rescue {}) || {} end def agent_diffs @agent_diffs || generate_diff end def import_confirmed? do_import == "1" end def import(options = {}) success = true guid = parsed_data['guid'] description = parsed_data['description'] name = parsed_data['name'] links = parsed_data['links'] control_links = parsed_data['control_links'] || [] tag_fg_color = parsed_data['tag_fg_color'] tag_bg_color = parsed_data['tag_bg_color'] icon = parsed_data['icon'] source_url = parsed_data['source_url'].presence || nil @scenario = user.scenarios.where(:guid => guid).first_or_initialize @scenario.update_attributes!(name: name, description: description, source_url: source_url, public: false, tag_fg_color: tag_fg_color, tag_bg_color: tag_bg_color, icon: icon) unless options[:skip_agents] created_agents = agent_diffs.map do |agent_diff| agent = agent_diff.agent || Agent.build_for_type("Agents::" + agent_diff.type.incoming, user) agent.guid = agent_diff.guid.incoming agent.attributes = { :name => agent_diff.name.updated, :disabled => agent_diff.disabled.updated, # == "true" :options => agent_diff.options.updated, :scenario_ids => [@scenario.id] } agent.schedule = agent_diff.schedule.updated if agent_diff.schedule.present? agent.keep_events_for = agent_diff.keep_events_for.updated if agent_diff.keep_events_for.present? agent.propagate_immediately = agent_diff.propagate_immediately.updated if agent_diff.propagate_immediately.present? # == "true" agent.service_id = agent_diff.service_id.updated if agent_diff.service_id.present? unless agent.save success = false errors.add(:base, "Errors when saving '#{agent_diff.name.incoming}': #{agent.errors.full_messages.to_sentence}") end agent end if success links.each do |link| receiver = created_agents[link['receiver']] source = created_agents[link['source']] receiver.sources << source unless receiver.sources.include?(source) end control_links.each do |control_link| controller = created_agents[control_link['controller']] control_target = created_agents[control_link['control_target']] controller.control_targets << control_target unless controller.control_targets.include?(control_target) end end end success end def scenario @scenario || @existing_scenario end protected def parse_file if data.blank? && file.present? self.data = file.read.force_encoding(Encoding::UTF_8) end end def fetch_url if data.blank? && url.present? && url =~ URL_REGEX self.data = Faraday.get(url).body end end def validate_data if data.present? @parsed_data = JSON.parse(data) rescue {} if (%w[name guid agents] - @parsed_data.keys).length > 0 errors.add(:base, "The provided data does not appear to be a valid Scenario.") self.data = nil end else @parsed_data = nil end end def validate_presence_of_file_url_or_data unless file.present? || url.present? || data.present? errors.add(:base, "Please provide either a Scenario JSON File or a Public Scenario URL.") end end def generate_diff @agent_diffs = (parsed_data['agents'] || []).map.with_index do |agent_data, index| # AgentDiff is defined at the end of this file. agent_diff = AgentDiff.new(agent_data, parsed_data['schema_version']) if existing_scenario # If this Agent exists already, update the AgentDiff with the local version's information. agent_diff.diff_with! existing_scenario.agents.find_by(:guid => agent_data['guid']) begin # Update the AgentDiff with any hand-merged changes coming from the UI. This only happens when this # Agent already exists locally and has conflicting changes. agent_diff.update_from! merges[index.to_s] if merges rescue JSON::ParserError errors.add(:base, "Your updated options for '#{agent_data['name']}' were unparsable.") end end if agent_diff.requires_service? && merges.present? && merges[index.to_s].present? && merges[index.to_s]['service_id'].present? agent_diff.service_id = AgentDiff::FieldDiff.new(merges[index.to_s]['service_id'].to_i) end agent_diff end end # AgentDiff is a helper object that encapsulates an incoming Agent. All fields will be returned as an array # of either one or two values. The first value is the incoming value, the second is the existing value, if # it differs from the incoming value. class AgentDiff < OpenStruct class FieldDiff attr_accessor :incoming, :current, :updated def initialize(incoming) @incoming = incoming @updated = incoming end def set_current(current) @current = current @requires_merge = (incoming != current) end def requires_merge? @requires_merge end end def initialize(agent_data, schema_version) super() @schema_version = schema_version @requires_merge = false self.agent = nil store! agent_data end BASE_FIELDS = %w[name schedule keep_events_for propagate_immediately disabled guid] FIELDS_REQUIRING_TRANSLATION = %w[keep_events_for] def agent_exists? !!agent end def requires_merge? @requires_merge end def requires_service? !!agent_instance.try(:oauthable?) end def store!(agent_data) self.type = FieldDiff.new(agent_data["type"].split("::").pop) self.options = FieldDiff.new(agent_data['options'] || {}) BASE_FIELDS.each do |option| if agent_data.has_key?(option) value = agent_data[option] value = send(:"translate_#{option}", value) if option.in?(FIELDS_REQUIRING_TRANSLATION) self[option] = FieldDiff.new(value) end end end def translate_keep_events_for(old_value) if schema_version < 1 # Was stored in days, now is stored in seconds. old_value.to_i.days else old_value end end def schema_version (@schema_version || 0).to_i end def diff_with!(agent) return unless agent.present? self.agent = agent type.set_current(agent.short_type) options.set_current(agent.options || {}) @requires_merge ||= type.requires_merge? @requires_merge ||= options.requires_merge? BASE_FIELDS.each do |field| next unless self[field].present? self[field].set_current(agent.send(field)) @requires_merge ||= self[field].requires_merge? end end def update_from!(merges) each_field do |field, value, selection_options| value.updated = merges[field] end if options.requires_merge? options.updated = JSON.parse(merges['options']) end end def each_field boolean = [["True", "true"], ["False", "false"]] yield 'name', name if name.requires_merge? yield 'schedule', schedule, Agent::SCHEDULES.map {|s| [s.humanize.titleize, s] } if self['schedule'].present? && schedule.requires_merge? yield 'keep_events_for', keep_events_for, Agent::EVENT_RETENTION_SCHEDULES if self['keep_events_for'].present? && keep_events_for.requires_merge? yield 'propagate_immediately', propagate_immediately, boolean if self['propagate_immediately'].present? && propagate_immediately.requires_merge? yield 'disabled', disabled, boolean if disabled.requires_merge? end def agent_instance "Agents::#{self.type.updated}".constantize.new end end end