Method: GoodData::Project.transfer_schedules

Defined in:

lib/gooddata/models/project.rb

.transfer_schedules(from_project, to_project, has_cycle_trigger = false) ⇒ Object

Clones project along with etl and schedules.

Object to be cloned from. Can be either segment in which case we take the master, client in which case we take its project, string in which case we treat is as an project object or directly project.

Parameters:

• client (GoodData::Rest::Client) —

  GoodData client to be used for connection

• from_project (GoodData::Project | GoodData::Segment | GoodData:Client | String)

# File 'lib/gooddata/models/project.rb', line 522

def transfer_schedules(from_project, to_project, has_cycle_trigger = false)
  to_project_processes = to_project.processes.sort_by(&:name)
  from_project_processes = from_project.processes.sort_by(&:name)
  from_project_processes.reject!(&:add_v2_component?)

  GoodData.logger.debug("Processes in from project #{from_project.pid}: #{from_project_processes.map(&:name).join(', ')}")
  GoodData.logger.debug("Processes in to project #{to_project.pid}: #{to_project_processes.map(&:name).join(', ')}")

  cache = to_project_processes
            .zip(from_project_processes)
            .flat_map do |remote, local|
              local.schedules.map do |schedule|
                [remote, local, schedule]
              end
            end

  remote_schedules = to_project.schedules
  remote_stuff = remote_schedules.map do |s|
    v = s.to_hash
    after_schedule = remote_schedules.find { |s2| s.trigger_id == s2.obj_id }
    v[:after] = s.trigger_id && after_schedule && after_schedule.name
    v[:remote_schedule] = s
    v[:params] = v[:params].except("EXECUTABLE", "PROCESS_ID")
    v.compact
  end

  local_schedules = from_project.schedules
  local_stuff = local_schedules.map do |s|
    v = s.to_hash
    after_schedule = local_schedules.find { |s2| s.trigger_id == s2.obj_id }
    after_process_schedule = from_project_processes.find { |p| after_schedule && p.obj_id == after_schedule.process_id }
    v[:after] = s.trigger_id && after_process_schedule && after_schedule && after_schedule.name
    v[:trigger_execution_status] = s.trigger_execution_status
    v[:remote_schedule] = s
    v[:params] = v[:params].except("EXECUTABLE", "PROCESS_ID")
    v.compact
  end

  diff = GoodData::Helpers.diff(remote_stuff, local_stuff, key: :name, fields: [:name, :cron, :after, :params, :hidden_params, :reschedule, :state])
  stack = diff[:added].map do |x|
    [:added, x]
  end

  stack += diff[:changed].map do |x|
    [:changed, x]
  end

  schedule_cache = remote_schedules.reduce({}) do |a, e|
    a[e.name] = e
    a
  end

  results = []
  update_trigger_schedules = []
  loop do # rubocop:disable Metrics/BlockLength
    break if stack.empty?
    state, changed_schedule = stack.shift
    lazy_update_trigger_info = false
    if state == :added
      schedule_spec = changed_schedule
      if schedule_spec[:after] && !schedule_cache[schedule_spec[:after]]
        if has_cycle_trigger
          # The schedule is triggered by another schedule
          lazy_update_trigger_info = true
        else
          stack << [state, schedule_spec]
          next
        end
      end

      remote_process, process_spec = cache.find do |_remote, local, schedule|
        (schedule_spec[:process_id] == local.process_id) && (schedule.name == schedule_spec[:name])
      end

      next unless remote_process || process_spec

      GoodData.logger.info("Creating schedule #{schedule_spec[:name]} for process #{remote_process.name}")

      executable = nil
      if process_spec.type != :dataload
        executable = schedule_spec[:executable] || (process_spec.type == :ruby ? 'main.rb' : 'main.grf')
      end

      params = schedule_parameters(schedule_spec)

      if lazy_update_trigger_info
        # Temporary update nil for trigger info. The trigger info will be update late after transfer all schedules
        created_schedule = remote_process.create_schedule(nil, executable, params)
        update_trigger_schedules << {
          state: :added,
          schedule: created_schedule,
          after: schedule_spec[:after]
        }
      else
        created_schedule = remote_process.create_schedule(schedule_spec[:cron] || schedule_cache[schedule_spec[:after]], executable, params)
      end

      schedule_cache[created_schedule.name] = created_schedule

      results << {
        state: :added,
        process: remote_process,
        schedule: created_schedule
      }
    else
      schedule_spec = changed_schedule[:new_obj]
      if schedule_spec[:after] && !schedule_cache[schedule_spec[:after]]
        if has_cycle_trigger
          # The schedule is triggered by another schedule
          lazy_update_trigger_info = true
        else
          stack << [state, schedule_spec]
          next
        end
      end

      remote_process, process_spec = cache.find do |i|
        i[2].name == schedule_spec[:name]
      end

      schedule = changed_schedule[:old_obj][:remote_schedule]

      GoodData.logger.info("Updating schedule #{schedule_spec[:name]} for process #{remote_process.name}")

      schedule.params = (schedule_spec[:params] || {})
      schedule.cron = schedule_spec[:cron] if schedule_spec[:cron]

      unless lazy_update_trigger_info
        schedule.after = schedule_cache[schedule_spec[:after]] if schedule_spec[:after]
        schedule.trigger_execution_status = schedule_cache[schedule_spec[:trigger_execution_status]] if schedule_spec[:after]
      end

      schedule.hidden_params = schedule_spec[:hidden_params] || {}
      if process_spec.type != :dataload
        schedule.executable = schedule_spec[:executable] || (process_spec.type == :ruby ? 'main.rb' : 'main.grf')
      end

      schedule.reschedule = schedule_spec[:reschedule]
      schedule.name = schedule_spec[:name]
      schedule.state = schedule_spec[:state]
      schedule.save
      schedule_cache[schedule.name] = schedule

      if lazy_update_trigger_info
        update_trigger_schedules << {
          state: :changed,
          schedule: schedule,
          after: schedule_spec[:after],
          trigger_execution_status: schedule_spec[:trigger_execution_status]
        }
      end

      results << {
        state: :changed,
        process: remote_process,
        schedule: schedule
      }
    end
  end

  if has_cycle_trigger
    update_trigger_schedules.each do |update_trigger_schedule|
      working_schedule = update_trigger_schedule[:schedule]
      working_schedule.after = schedule_cache[update_trigger_schedule[:after]]
      working_schedule.trigger_execution_status = schedule_cache[update_trigger_schedule[:trigger_execution_status]] if update_trigger_schedule[:state] == :changed

      # Update trigger info
      working_schedule.save

      # Update transfer result
      results.each do |transfer_result|
        transfer_result[:schedule] = working_schedule if transfer_result[:schedule].obj_id == working_schedule.obj_id
      end
    end
  end

  diff[:removed].each do |removed_schedule|
    GoodData.logger.info("Removing schedule #{removed_schedule[:name]}")

    removed_schedule[:remote_schedule].delete

    results << {
      state: :removed,
      process: removed_schedule.process,
      schedule: removed_schedule
    }
  end

  results
end