eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

APPS.FND_OAM_DSCRAM_UNITS_PKG dependencies on FND_OAM_DSCRAM_UTILS_PKG

Line 17: AND unit_status in (FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_UNPROCESSED,

13: IS
14: SELECT /*+ FIRST_ROWS(1) */ unit_id, unit_status, phase, actual_workers_allowed, workers_assigned
15: FROM fnd_oam_dscram_units
16: WHERE task_id = FND_OAM_DSCRAM_TASKS_PKG.GET_TASK_ID
17: AND unit_status in (FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_UNPROCESSED,
18: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSING,
19: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_RESTARTABLE,
20: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_FINISHING) --need to include finishing to keep from violating phases
21: AND concurrent_group_unit_id IS NULL --only select top-level units, all units with a conc_unit_id should belong to a parent unit

Line 18: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSING,

14: SELECT /*+ FIRST_ROWS(1) */ unit_id, unit_status, phase, actual_workers_allowed, workers_assigned
15: FROM fnd_oam_dscram_units
16: WHERE task_id = FND_OAM_DSCRAM_TASKS_PKG.GET_TASK_ID
17: AND unit_status in (FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_UNPROCESSED,
18: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSING,
19: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_RESTARTABLE,
20: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_FINISHING) --need to include finishing to keep from violating phases
21: AND concurrent_group_unit_id IS NULL --only select top-level units, all units with a conc_unit_id should belong to a parent unit
22: ORDER BY phase ASC, priority ASC, weight DESC;

Line 19: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_RESTARTABLE,

15: FROM fnd_oam_dscram_units
16: WHERE task_id = FND_OAM_DSCRAM_TASKS_PKG.GET_TASK_ID
17: AND unit_status in (FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_UNPROCESSED,
18: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSING,
19: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_RESTARTABLE,
20: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_FINISHING) --need to include finishing to keep from violating phases
21: AND concurrent_group_unit_id IS NULL --only select top-level units, all units with a conc_unit_id should belong to a parent unit
22: ORDER BY phase ASC, priority ASC, weight DESC;
23:

Line 20: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_FINISHING) --need to include finishing to keep from violating phases

16: WHERE task_id = FND_OAM_DSCRAM_TASKS_PKG.GET_TASK_ID
17: AND unit_status in (FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_UNPROCESSED,
18: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSING,
19: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_RESTARTABLE,
20: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_FINISHING) --need to include finishing to keep from violating phases
21: AND concurrent_group_unit_id IS NULL --only select top-level units, all units with a conc_unit_id should belong to a parent unit
22: ORDER BY phase ASC, priority ASC, weight DESC;
23:
24: TYPE b_unit_cache_type IS RECORD

Line 165: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_EMPTY;

161: -- no rows is an empty
162: IF B_UNITS%NOTFOUND THEN
163: fnd_oam_debug.log(1, l_ctxt, 'B_UNITS empty');
164: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
165: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_EMPTY;
166: CLOSE B_UNITS;
167: RETURN;
168: END IF;
169:

Line 178: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_FULL;

174: -- if the last_phase isn't null, make sure we're not looking at a unit in a later
175: -- phase, makes the assumption that there is no phase after null.
176: IF b_last_fetched_unit_phase IS NOT NULL AND
177: (l_phase IS NULL OR b_last_fetched_unit_phase < l_phase) THEN
178: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_FULL;
179: -- close the cursor to allow the current, invalid unit to get queried up next time
180: CLOSE B_UNITS;
181: fnd_oam_debug.log(1, l_ctxt, 'Unit Phase('||l_phase||') later than last_phase('||b_last_fetched_unit_phase||')');
182: fnd_oam_debug.log(2, l_ctxt, 'EXIT');

Line 187: IF l_status = FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_FINISHING THEN

183: RETURN;
184: END IF;
185:
186: --if the unit's finishing, we're just here to log its phase and fetch the next - we can't return this unit
187: IF l_status = FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_FINISHING THEN
188: fnd_oam_debug.log(1, l_ctxt, 'Found finishing unit, Fetching Next');
189: ELSE
190: -- see if there's space in the unit
191: IF l_workers_allowed IS NULL OR l_workers_assigned < l_workers_allowed THEN

Line 209: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_FULL;

205: FETCH B_UNITS INTO l_unit_id, l_status, l_phase, l_workers_allowed, l_workers_assigned;
206:
207: -- no rows at this point isn't an empty but a full
208: IF B_UNITS%NOTFOUND THEN
209: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_FULL;
210: CLOSE B_UNITS;
211: fnd_oam_debug.log(1, l_ctxt, 'No more units to Fetch');
212: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
213: RETURN;

Line 279: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_EXECUTABLE(l_status) THEN

275: END IF;
276: CLOSE C1;
277:
278: --check that the status executes it's executable
279: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_EXECUTABLE(l_status) THEN
280: -- report the true status of the unit to execute to pass on to execute's caller
281: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_START_STS_TO_RET(l_status);
282: IF FND_OAM_DSCRAM_UTILS_PKG.RET_STS_IS_ERROR(x_return_status) THEN
283: x_return_msg := 'Invalid task status('||l_status||')';

Line 281: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_START_STS_TO_RET(l_status);

277:
278: --check that the status executes it's executable
279: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_EXECUTABLE(l_status) THEN
280: -- report the true status of the unit to execute to pass on to execute's caller
281: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_START_STS_TO_RET(l_status);
282: IF FND_OAM_DSCRAM_UTILS_PKG.RET_STS_IS_ERROR(x_return_status) THEN
283: x_return_msg := 'Invalid task status('||l_status||')';
284: fnd_oam_debug.log(1, l_ctxt, x_return_msg);
285: END IF;

Line 282: IF FND_OAM_DSCRAM_UTILS_PKG.RET_STS_IS_ERROR(x_return_status) THEN

278: --check that the status executes it's executable
279: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_EXECUTABLE(l_status) THEN
280: -- report the true status of the unit to execute to pass on to execute's caller
281: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_START_STS_TO_RET(l_status);
282: IF FND_OAM_DSCRAM_UTILS_PKG.RET_STS_IS_ERROR(x_return_status) THEN
283: x_return_msg := 'Invalid task status('||l_status||')';
284: fnd_oam_debug.log(1, l_ctxt, x_return_msg);
285: END IF;
286: fnd_oam_debug.log(2, l_ctxt, 'EXIT');

Line 335: FND_OAM_DSCRAM_UTILS_PKG.VALIDATION_DUE(b_unit_info.last_validated)) THEN

331: END IF;
332:
333: -- check if we should do work or if we can presume the cached status
334: IF (p_force_query OR
335: FND_OAM_DSCRAM_UTILS_PKG.VALIDATION_DUE(b_unit_info.last_validated)) THEN
336:
337: fnd_oam_debug.log(1, l_ctxt, '>RE-QUERYING<');
338:
339: -- re-init the cached fields to allow easy exit

Line 355: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_PROCESSING(l_status) THEN

351: END IF;
352: CLOSE C1;
353:
354: --make sure the unit has been marked as processing
355: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_PROCESSING(l_status) THEN
356: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_CONT_STS_TO_RET(l_status);
357: b_unit_info.last_validation_ret_sts := x_return_status;
358: IF x_return_status <> FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_PROCESSED THEN
359: x_return_msg := 'Invalid unit status('||l_status||')';

Line 356: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_CONT_STS_TO_RET(l_status);

352: CLOSE C1;
353:
354: --make sure the unit has been marked as processing
355: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_PROCESSING(l_status) THEN
356: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_CONT_STS_TO_RET(l_status);
357: b_unit_info.last_validation_ret_sts := x_return_status;
358: IF x_return_status <> FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_PROCESSED THEN
359: x_return_msg := 'Invalid unit status('||l_status||')';
360: fnd_oam_debug.log(1, l_ctxt, x_return_msg);

Line 358: IF x_return_status <> FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_PROCESSED THEN

354: --make sure the unit has been marked as processing
355: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_PROCESSING(l_status) THEN
356: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_CONT_STS_TO_RET(l_status);
357: b_unit_info.last_validation_ret_sts := x_return_status;
358: IF x_return_status <> FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_PROCESSED THEN
359: x_return_msg := 'Invalid unit status('||l_status||')';
360: fnd_oam_debug.log(1, l_ctxt, x_return_msg);
361: END IF;
362: RETURN FALSE;

Line 376: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_STOPPED;

372: TRUE,
373: l_return_status,
374: l_return_msg) THEN
375: -- the run has an invalid status, tell the execute to stop the unit
376: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_STOPPED;
377: x_return_msg := '[Continued Validation of Parent(s) Failed]:(Status('||l_return_status||'), Msg('||l_return_msg||'))';
378: fnd_oam_debug.log(1, l_ctxt, x_return_msg);
379: RETURN FALSE;
380: END IF;

Line 447: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_EXECUTABLE(l_status) THEN

443: fnd_oam_debug.log(1, l_ctxt, 'Unit Status: '||l_status);
444: fnd_oam_debug.log(1, l_ctxt, 'Workers Allow(Sug/Act), Assigned: ('||l_suggest_workers_allowed||')('||l_actual_workers_allowed||'), '||l_workers_assigned||')');
445:
446: -- make sure the status is runnable after the lock
447: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_EXECUTABLE(l_status) THEN
448: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_START_STS_TO_RET(l_status);
449: IF FND_OAM_DSCRAM_UTILS_PKG.RET_STS_IS_ERROR(x_return_status) THEN
450: x_return_msg := 'Invalid unit in assign, status('||l_status||')';
451: fnd_oam_debug.log(1, l_ctxt, x_return_msg);

Line 448: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_START_STS_TO_RET(l_status);

444: fnd_oam_debug.log(1, l_ctxt, 'Workers Allow(Sug/Act), Assigned: ('||l_suggest_workers_allowed||')('||l_actual_workers_allowed||'), '||l_workers_assigned||')');
445:
446: -- make sure the status is runnable after the lock
447: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_EXECUTABLE(l_status) THEN
448: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_START_STS_TO_RET(l_status);
449: IF FND_OAM_DSCRAM_UTILS_PKG.RET_STS_IS_ERROR(x_return_status) THEN
450: x_return_msg := 'Invalid unit in assign, status('||l_status||')';
451: fnd_oam_debug.log(1, l_ctxt, x_return_msg);
452: END IF;

Line 449: IF FND_OAM_DSCRAM_UTILS_PKG.RET_STS_IS_ERROR(x_return_status) THEN

445:
446: -- make sure the status is runnable after the lock
447: IF NOT FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_EXECUTABLE(l_status) THEN
448: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_VALIDATE_START_STS_TO_RET(l_status);
449: IF FND_OAM_DSCRAM_UTILS_PKG.RET_STS_IS_ERROR(x_return_status) THEN
450: x_return_msg := 'Invalid unit in assign, status('||l_status||')';
451: fnd_oam_debug.log(1, l_ctxt, x_return_msg);
452: END IF;
453: fnd_oam_debug.log(2, l_ctxt, 'EXIT');

Line 463: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_FULL;

459: IF ((l_actual_workers_allowed IS NOT NULL AND
460: l_workers_assigned >= l_actual_workers_allowed) OR
461: (l_actual_workers_allowed IS NULL AND
462: l_workers_assigned >= l_suggest_workers_allowed)) THEN
463: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_FULL;
464: fnd_oam_debug.log(1, l_ctxt, 'No workers slot available, returning full.');
465: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
466: ROLLBACK;
467: RETURN;

Line 471: IF l_status <> FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSING THEN

467: RETURN;
468: END IF;
469:
470: -- first start, create a stats entry
471: IF l_status <> FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSING THEN
472: IF l_workers_assigned = 0 THEN
473: --create a stats entry
474: FND_OAM_DSCRAM_STATS_PKG.CREATE_ENTRY(p_source_object_type => FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_UNIT,
475: p_source_object_id => p_unit_id,

Line 474: FND_OAM_DSCRAM_STATS_PKG.CREATE_ENTRY(p_source_object_type => FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_UNIT,

470: -- first start, create a stats entry
471: IF l_status <> FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSING THEN
472: IF l_workers_assigned = 0 THEN
473: --create a stats entry
474: FND_OAM_DSCRAM_STATS_PKG.CREATE_ENTRY(p_source_object_type => FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_UNIT,
475: p_source_object_id => p_unit_id,
476: p_start_time => SYSDATE,
477: p_prestart_status => l_status,
478: x_stat_id => l_stat_id);

Line 502: SET unit_status = FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSING,

498: l_actual_disable_splitting := NVL(l_actual_disable_splitting, NVL(l_suggest_disable_splitting, FND_API.G_FALSE));
499:
500: -- update the status and other fields
501: UPDATE fnd_oam_dscram_units
502: SET unit_status = FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSING,
503: stats_finished = FND_API.G_FALSE,
504: actual_workers_allowed = l_actual_workers_allowed,
505: actual_disable_splitting = l_actual_disable_splitting
506: WHERE unit_id = p_unit_id;

Line 518: l_use_splitting := NOT(FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(l_actual_disable_splitting));

514: END IF;
515: END IF;
516:
517: -- convert our splitting decision
518: l_use_splitting := NOT(FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(l_actual_disable_splitting));
519:
520: -- finally, always update the last updated fields and the # of workers assigned.
521: UPDATE fnd_oam_dscram_units
522: SET workers_assigned = workers_assigned + 1,

Line 616: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN

612:
613: k := px_work_queue_to_complete.FIRST;
614: WHILE k IS NOT NULL LOOP
615: CASE px_work_queue_to_complete(k).item_type
616: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN
617: FND_OAM_DSCRAM_DMLS_PKG.UPDATE_COMP_DML_WRITABLE_ARGS(px_work_queue_to_complete(k).item_id,
618: px_arg_context,
619: b_unit_info.use_splitting,
620: l_proposed_ret_sts,

Line 623: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN

619: b_unit_info.use_splitting,
620: l_proposed_ret_sts,
621: l_return_msg);
622:
623: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN
624: FND_OAM_DSCRAM_PLSQLS_PKG.UPDATE_COMP_PLS_WRITABLE_ARGS(px_work_queue_to_complete(k).item_id,
625: px_arg_context,
626: b_unit_info.use_splitting,
627: l_proposed_ret_sts,

Line 639: l_proposed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_UNKNOWN;

635: END CASE;
636:
637: --if the called update method failed, exit early
638: IF l_proposed_ret_sts <> FND_API.G_RET_STS_SUCCESS THEN
639: l_proposed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_UNKNOWN;
640: --store the failure message on the item
641: px_work_queue_to_complete(k).item_msg := l_return_msg||px_work_queue_to_complete(k).item_msg;
642: --stop processing the loop
643: EXIT;

Line 662: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN

658: --entry, which defaults to NULL to use the work item's cache message.
659: k := px_work_queue_to_complete.FIRST;
660: WHILE k IS NOT NULL LOOP
661: CASE px_work_queue_to_complete(k).item_type
662: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN
663: FND_OAM_DSCRAM_DMLS_PKG.COMPLETE_DML(px_work_queue_to_complete(k).item_id,
664: l_proposed_ret_sts,
665: px_work_queue_to_complete(k).item_msg,
666: l_workers_assigned,

Line 670: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN

666: l_workers_assigned,
667: l_return_status,
668: l_return_msg);
669:
670: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN
671: --since pl/sqls don't write the # of rows processed, they only need to be completed by the last worker
672: IF l_workers_assigned = 1 THEN
673: FND_OAM_DSCRAM_PLSQLS_PKG.COMPLETE_PLSQL(px_work_queue_to_complete(k).item_id,
674: l_proposed_ret_sts,

Line 702: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN

698: --set_context to update the real context object.
699: k := px_work_queue_to_complete.FIRST;
700: WHILE k IS NOT NULL LOOP
701: CASE px_work_queue_to_complete(k).item_type
702: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN
703: FND_OAM_DSCRAM_DMLS_PKG.DESTROY_DML_CACHE_ENTRY(px_work_queue_to_complete(k).item_id,
704: px_arg_context,
705: l_update_context,
706: l_return_status,

Line 709: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN

705: l_update_context,
706: l_return_status,
707: l_return_msg);
708:
709: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN
710: FND_OAM_DSCRAM_PLSQLS_PKG.DESTROY_PLSQL_CACHE_ENTRY(px_work_queue_to_complete(k).item_id,
711: px_arg_context,
712: l_update_context,
713: l_return_status,

Line 733: l_proposed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_UNKNOWN;

729: END IF;
730: EXCEPTION
731: WHEN OTHERS THEN
732: --if anything went wrong while processing the work units, still complete the unit but with an error
733: l_proposed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_UNKNOWN;
734: l_proposed_ret_sts := FND_API.G_RET_STS_UNEXP_ERROR;
735: END;
736: END IF;
737:

Line 746: NOT FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_NORMAL THEN

742: FND_OAM_DSCRAM_DMLS_PKG.DESTROY_DML_CACHE(px_arg_context,
743: l_return_status,
744: l_return_msg);
745: IF l_return_status <> FND_API.G_RET_STS_SUCCESS AND
746: NOT FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_NORMAL THEN
747: --only error when failing to destory if we're in a non-normal mode
748: l_message := l_return_msg;
749: RAISE COMPLETE_FAILED;
750: END IF;

Line 757: NOT FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_NORMAL THEN

753: FND_OAM_DSCRAM_PLSQLS_PKG.DESTROY_PLSQL_CACHE(px_arg_context,
754: l_return_status,
755: l_return_msg);
756: IF l_return_status <> FND_API.G_RET_STS_SUCCESS AND
757: NOT FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_NORMAL THEN
758: --only error when failing to destory if we're in a non-normal mode
759: l_message := l_return_msg;
760: RAISE COMPLETE_FAILED;
761: END IF;

Line 765: l_proposed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_UNKNOWN;

761: END IF;
762: EXCEPTION
763: WHEN OTHERS THEN
764: --if anything went wrong in the DMLs, still complete the unit, just differently
765: l_proposed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_UNKNOWN;
766: l_proposed_ret_sts := FND_API.G_RET_STS_UNEXP_ERROR;
767: END;
768: END IF;
769:

Line 771: FND_OAM_DSCRAM_UTILS_PKG.TRANSLATE_COMPLETED_STATUS(l_status,

767: END;
768: END IF;
769:
770: -- translate the new_status into a valid final status
771: FND_OAM_DSCRAM_UTILS_PKG.TRANSLATE_COMPLETED_STATUS(l_status,
772: l_workers_assigned,
773: l_proposed_status,
774: l_proposed_ret_sts,
775: l_final_status,

Line 781: IF l_final_ret_sts = FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_FULL AND l_workers_assigned > 1 THEN

777: fnd_oam_debug.log(1, l_ctxt, 'Translated status "'||l_proposed_status||'" into "'||l_final_status||'"');
778: fnd_oam_debug.log(1, l_ctxt, 'Translated Execute Ret Sts "'||l_proposed_ret_sts||'" into "'||l_final_ret_sts||'"');
779:
780: --if we discovered that we're full, possibly temporarily, just decrement the worker count and leave if we're not the last worker
781: IF l_final_ret_sts = FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_FULL AND l_workers_assigned > 1 THEN
782: UPDATE fnd_oam_dscram_units
783: SET workers_assigned = workers_assigned - 1,
784: last_updated_by = fnd_global.user_id,
785: last_update_login = fnd_global.user_id,

Line 800: FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_FINAL(l_final_status) THEN

796: WHERE unit_id = p_unit_id;
797:
798: --only complete stats if we changed state
799: IF l_final_status <> l_status AND
800: FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_FINAL(l_final_status) THEN
801:
802: FND_OAM_DSCRAM_STATS_PKG.COMPLETE_ENTRY(p_source_object_type => FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_UNIT,
803: p_source_object_id => p_unit_id,
804: p_end_time => SYSDATE,

Line 802: FND_OAM_DSCRAM_STATS_PKG.COMPLETE_ENTRY(p_source_object_type => FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_UNIT,

798: --only complete stats if we changed state
799: IF l_final_status <> l_status AND
800: FND_OAM_DSCRAM_UTILS_PKG.STATUS_IS_FINAL(l_final_status) THEN
801:
802: FND_OAM_DSCRAM_STATS_PKG.COMPLETE_ENTRY(p_source_object_type => FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_UNIT,
803: p_source_object_id => p_unit_id,
804: p_end_time => SYSDATE,
805: p_postend_status => l_final_status,
806: p_end_message => l_message);

Line 882: X_script => FND_OAM_DSCRAM_UTILS_PKG.MAKE_AD_SCRIPT_KEY(p_unit_id),

878: --Values in the bundle are non-null and these fields are required for AD to function in the multi-worker case.
879: AD_PARALLEL_UPDATES_PKG.INITIALIZE_ROWID_RANGE(X_update_type => AD_PARALLEL_UPDATES_PKG.ROWID_RANGE,
880: X_owner => p_object_owner,
881: X_table => p_object_name,
882: X_script => FND_OAM_DSCRAM_UTILS_PKG.MAKE_AD_SCRIPT_KEY(p_unit_id),
883: X_worker_id => FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKER_ID,
884: X_num_workers => NVL(p_num_workers, FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKERS_ALLOWED),
885: X_batch_size => NVL(p_batch_size, FND_OAM_DSCRAM_BUNDLES_PKG.GET_BATCH_SIZE),
886: X_debug_level => 0,

Line 1071: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN

1067: k := px_work_queue.FIRST;
1068: WHILE k IS NOT NULL LOOP
1069: --choose the proper execution function
1070: CASE px_work_queue(k).item_type
1071: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN
1072: FND_OAM_DSCRAM_DMLS_PKG.EXECUTE_DML_ON_RANGE(px_work_queue(k).item_id,
1073: px_arg_context,
1074: l_rowid_lbound,
1075: l_rowid_ubound,

Line 1080: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN

1076: l_rows_processed,
1077: l_return_status,
1078: l_return_msg);
1079:
1080: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN
1081: --set rows processed to zero sinze pl/sql procedures don't report it
1082: l_rows_processed := 0;
1083: FND_OAM_DSCRAM_PLSQLS_PKG.EXECUTE_PLSQL_ON_RANGE(px_work_queue(k).item_id,
1084: px_arg_context,

Line 1126: IF FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_NORMAL THEN

1122: k := px_work_queue.NEXT(k);
1123: END LOOP;
1124:
1125: --if we got here, all the work items must have suceeded, complete the ad range
1126: IF FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_NORMAL THEN
1127: COMPLETE_AD_RANGE(l_rowid_ubound,
1128: l_max_range_rows_processed);
1129: COMMIT;
1130: ELSE

Line 1161: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN

1157: k := px_work_queue.FIRST;
1158: WHILE k IS NOT NULL LOOP
1159: --choose the proper execution function, entity stats are created and completed within these functions
1160: CASE px_work_queue(k).item_type
1161: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN
1162: FND_OAM_DSCRAM_DMLS_PKG.EXECUTE_DML(px_work_queue(k).item_id,
1163: px_arg_context,
1164: l_return_status,
1165: l_return_msg);

Line 1167: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN

1163: px_arg_context,
1164: l_return_status,
1165: l_return_msg);
1166:
1167: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN
1168: FND_OAM_DSCRAM_PLSQLS_PKG.EXECUTE_PLSQL(px_work_queue(k).item_id,
1169: px_arg_context,
1170: l_return_status,
1171: l_return_msg);

Line 1184: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN

1180: --see if our work suceeded or not
1181: IF l_return_status = FND_API.G_RET_STS_SUCCESS THEN
1182: --destroy the work item's cache entry exp to get its arg list pushed into the arg context
1183: CASE px_work_queue(k).item_type
1184: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_DML THEN
1185: FND_OAM_DSCRAM_DMLS_PKG.DESTROY_DML_CACHE_ENTRY(px_work_queue(k).item_id,
1186: px_arg_context,
1187: TRUE,
1188: l_return_status,

Line 1191: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN

1187: TRUE,
1188: l_return_status,
1189: l_return_msg);
1190:
1191: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_PLSQL THEN
1192: FND_OAM_DSCRAM_PLSQLS_PKG.DESTROY_PLSQL_CACHE_ENTRY(px_work_queue(k).item_id,
1193: px_arg_context,
1194: TRUE,
1195: l_return_status,

Line 1215: IF FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_NORMAL THEN

1211:
1212: --at this point, the work item was sucessfully executed and its cache entry was removed, commit the work
1213: --on success, we can commit the completed DML locally (unless we're in a non-normal mode)
1214: --to mark our incremental success since we're the only worker.
1215: IF FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_NORMAL THEN
1216: COMMIT;
1217: ELSE
1218: fnd_oam_debug.log(1, l_ctxt, 'Rolling back changes because of non-standard run mode');
1219: ROLLBACK;

Line 1458: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_UNIT_TYPE_DML_SET THEN

1454: k := l_unit_ids.FIRST;
1455: WHILE k IS NOT NULL LOOP
1456: --based on the type, call a different API to get the work queue for this child unit
1457: CASE l_types(k)
1458: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_UNIT_TYPE_DML_SET THEN
1459: FND_OAM_DSCRAM_DMLS_PKG.FETCH_DML_IDS(l_unit_ids(k),
1460: l_work_queue,
1461: l_return_status,
1462: l_return_msg);

Line 1463: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_UNIT_TYPE_PLSQL_SET THEN

1459: FND_OAM_DSCRAM_DMLS_PKG.FETCH_DML_IDS(l_unit_ids(k),
1460: l_work_queue,
1461: l_return_status,
1462: l_return_msg);
1463: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_UNIT_TYPE_PLSQL_SET THEN
1464: FND_OAM_DSCRAM_PLSQLS_PKG.FETCH_PLSQL_IDS(l_unit_ids(k),
1465: l_work_queue,
1466: l_return_status,
1467: l_return_msg);

Line 1627: IF l_return_status <> FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_FULL THEN

1623: l_return_status,
1624: l_return_msg);
1625: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
1626: x_return_status := l_return_status;
1627: IF l_return_status <> FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_FULL THEN
1628: x_return_msg := '[Unit Worker Assignment Failed]:('||l_return_msg||')';
1629: fnd_oam_debug.log(1, l_ctxt, x_return_msg);
1630: END IF;
1631: fnd_oam_debug.log(2, l_ctxt, 'EXIT');

Line 1644: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_STOPPED,

1640: l_return_msg) THEN
1641: --we don't care why a parent is invalid, just knowing so forces us to
1642: --stop our work
1643: COMPLETE_UNIT_IN_ERROR(b_unit_info.unit_id,
1644: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_STOPPED,
1645: FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_STOPPED,
1646: l_return_msg,
1647: x_return_status);
1648: x_return_msg := '[Post-Assignment Parent Validation Failed]:('||l_return_msg||')';

Line 1645: FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_STOPPED,

1641: --we don't care why a parent is invalid, just knowing so forces us to
1642: --stop our work
1643: COMPLETE_UNIT_IN_ERROR(b_unit_info.unit_id,
1644: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_STOPPED,
1645: FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_STOPPED,
1646: l_return_msg,
1647: x_return_status);
1648: x_return_msg := '[Post-Assignment Parent Validation Failed]:('||l_return_msg||')';
1649: fnd_oam_debug.log(1, l_ctxt, x_return_msg);

Line 1671: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_UNIT_TYPE_DML_SET THEN

1667: END IF;
1668:
1669: --delegate the work to different procedures based on the unit type
1670: CASE b_unit_info.unit_type
1671: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_UNIT_TYPE_DML_SET THEN
1672: EXECUTE_DML_SET_UNIT(l_arg_context,
1673: l_work_queue_to_complete,
1674: l_return_status,
1675: l_return_msg);

Line 1677: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_UNIT_TYPE_PLSQL_SET THEN

1673: l_work_queue_to_complete,
1674: l_return_status,
1675: l_return_msg);
1676:
1677: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_UNIT_TYPE_PLSQL_SET THEN
1678: EXECUTE_PLSQL_SET_UNIT(l_arg_context,
1679: l_work_queue_to_complete,
1680: l_return_status,
1681: l_return_msg);

Line 1683: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_UNIT_TYPE_CONC_GROUP THEN

1679: l_work_queue_to_complete,
1680: l_return_status,
1681: l_return_msg);
1682:
1683: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_UNIT_TYPE_CONC_GROUP THEN
1684: EXECUTE_CONC_GROUP_UNIT(l_arg_context,
1685: l_work_queue_to_complete,
1686: l_return_status,
1687: l_return_msg);

Line 1696: l_completed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSED;

1692:
1693: --determine the status to apply to the unit from the execute's return status
1694: IF l_return_status = FND_API.G_RET_STS_SUCCESS THEN
1695: --unit was sucessful
1696: l_completed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSED;
1697: ELSE
1698: --determine what status the unit should have
1699: l_completed_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_RET_STS_TO_COMPL_STATUS(l_return_status);
1700:

Line 1699: l_completed_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_RET_STS_TO_COMPL_STATUS(l_return_status);

1695: --unit was sucessful
1696: l_completed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSED;
1697: ELSE
1698: --determine what status the unit should have
1699: l_completed_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_RET_STS_TO_COMPL_STATUS(l_return_status);
1700:
1701: --take the fatality level into account to error out parent objects if need be
1702: IF l_completed_status <> FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSED AND
1703: b_unit_info.error_fatality_level IS NOT NULL THEN

Line 1702: IF l_completed_status <> FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSED AND

1698: --determine what status the unit should have
1699: l_completed_status := FND_OAM_DSCRAM_UTILS_PKG.CONV_RET_STS_TO_COMPL_STATUS(l_return_status);
1700:
1701: --take the fatality level into account to error out parent objects if need be
1702: IF l_completed_status <> FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSED AND
1703: b_unit_info.error_fatality_level IS NOT NULL THEN
1704:
1705: --update the corresponding parent unit
1706: FND_OAM_DSCRAM_UTILS_PKG.PROPOGATE_FATALITY_LEVEL(b_unit_info.error_fatality_level);

Line 1706: FND_OAM_DSCRAM_UTILS_PKG.PROPOGATE_FATALITY_LEVEL(b_unit_info.error_fatality_level);

1702: IF l_completed_status <> FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_PROCESSED AND
1703: b_unit_info.error_fatality_level IS NOT NULL THEN
1704:
1705: --update the corresponding parent unit
1706: FND_OAM_DSCRAM_UTILS_PKG.PROPOGATE_FATALITY_LEVEL(b_unit_info.error_fatality_level);
1707:
1708: --also change our status to error_fatal
1709: l_completed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_FATAL;
1710: END IF;

Line 1709: l_completed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_FATAL;

1705: --update the corresponding parent unit
1706: FND_OAM_DSCRAM_UTILS_PKG.PROPOGATE_FATALITY_LEVEL(b_unit_info.error_fatality_level);
1707:
1708: --also change our status to error_fatal
1709: l_completed_status := FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_FATAL;
1710: END IF;
1711: END IF;
1712:
1713: --finished processing the unit

Line 1742: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_UNKNOWN,

1738: fnd_oam_debug.log(6, l_ctxt, x_return_msg);
1739: --safety rollback
1740: ROLLBACK;
1741: COMPLETE_UNIT_IN_ERROR(p_unit_id,
1742: FND_OAM_DSCRAM_UTILS_PKG.G_STATUS_ERROR_UNKNOWN,
1743: FND_API.G_RET_STS_UNEXP_ERROR,
1744: x_return_msg,
1745: x_return_status);
1746: END;