composer/iTop
6
0
Fork 0
mirror of https://github.com/Combodo/iTop.git synced 2026-02-13 07:24:13 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
a39234f438e5116be3421e1505bc53be609fb59b
iTop/synchro/synchrodatasource.class.inc.php

3554 lines
125 KiB
PHP
Raw Blame History

<?php
/*
* @copyright Copyright (C) 2010-2024 Combodo SAS
* @license http://opensource.org/licenses/AGPL-3.0
*/
use Combodo\iTop\Application\WebPage\WebPage;
class SynchroDataSource extends cmdbAbstractObject
{
public static function Init()
{
$oStyle = new ormStyle("", "");
$oStyle->SetIcon('../images/synchro.png');
$aParams = [
'category' => 'core/cmdb,view_in_gui,grant_by_profile',
'key_type' => 'autoincrement',
'name_attcode' => ['name'],
'state_attcode' => '',
'reconc_keys' => [],
'db_table' => 'priv_sync_datasource',
'db_key_field' => 'id',
'db_finalclass_field' => 'realclass',
'display_template' => '',
'style' => $oStyle,
];
MetaModel::Init_Params($aParams);
//MetaModel::Init_InheritAttributes();
MetaModel::Init_AddAttribute(new AttributeString('name', [
'allowed_values' => null,
'sql' => 'name',
'default_value' => null,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeText('description', [
'allowed_values' => null,
'sql' => 'description',
'default_value' => null,
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeEnum('status', [
'allowed_values' => new ValueSetEnum('implementation,production,obsolete'),
'sql' => 'status',
'default_value' => 'implementation',
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeExternalKey('user_id', [
'targetclass' => 'User',
'jointype' => null,
'allowed_values' => null,
'sql' => 'user_id',
'is_null_allowed' => true,
'on_target_delete' => DEL_MANUAL,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeExternalKey('notify_contact_id', [
'targetclass' => 'Contact',
'jointype' => null,
'allowed_values' => null,
'sql' => 'notify_contact_id',
'is_null_allowed' => true,
'on_target_delete' => DEL_MANUAL,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeClass('scope_class', [
'class_category' => 'bizmodel,addon/authentication,application',
'more_values' => '',
'sql' => 'scope_class',
'default_value' => null,
'is_null_allowed' => false,
'depends_on' => [],
"class_exclusion_list" => null,
]));
MetaModel::Init_AddAttribute(new AttributeString('database_table_name', [
'allowed_values' => null,
'sql' => 'database_table_name',
'default_value' => null,
'is_null_allowed' => true,
'depends_on' => [],
'validation_pattern' => '^[A-Za-z0-9_]*$',
]));
// Declared here for a future usage, but ignored so far
MetaModel::Init_AddAttribute(new AttributeString('scope_restriction', [
'allowed_values' => null,
'sql' => 'scope_restriction',
'default_value' => null,
'is_null_allowed' => true,
'depends_on' => [],
]));
//MetaModel::Init_AddAttribute(new AttributeDateTime("last_synchro_date", array("allowed_values"=>null, "sql"=>"last_synchro_date", "default_value"=>"NOW()", "is_null_allowed"=>false, "depends_on"=>array())));
// Format: seconds (int)
MetaModel::Init_AddAttribute(new AttributeDuration('full_load_periodicity', [
'allowed_values' => null,
'sql' => 'full_load_periodicity',
'default_value' => 0,
'is_null_allowed' => true,
'depends_on' => [],
]));
// MetaModel::Init_AddAttribute(new AttributeString("reconciliation_list", array("allowed_values"=>null, "sql"=>"reconciliation_list", "default_value"=>null, "is_null_allowed"=>false, "depends_on"=>array())));
MetaModel::Init_AddAttribute(new AttributeEnum('reconciliation_policy', [
'allowed_values' => new ValueSetEnum('use_primary_key,use_attributes'),
'sql' => 'reconciliation_policy',
'default_value' => 'use_attributes',
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeEnum('action_on_zero', [
'allowed_values' => new ValueSetEnum('create,error'),
'sql' => 'action_on_zero',
'default_value' => 'create',
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeEnum('action_on_one', [
'allowed_values' => new ValueSetEnum('update,error'),
'sql' => 'action_on_one',
'default_value' => 'update',
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeEnum('action_on_multiple', [
'allowed_values' => new ValueSetEnum('take_first,create,error'),
'sql' => 'action_on_multiple',
'default_value' => 'error',
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeEnum('delete_policy', [
'allowed_values' => new ValueSetEnum('ignore,delete,update,update_then_delete'),
'sql' => 'delete_policy',
'default_value' => 'ignore',
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeString('delete_policy_update', [
'allowed_values' => null,
'sql' => 'delete_policy_update',
'default_value' => null,
'is_null_allowed' => true,
'depends_on' => [],
]));
// Format: seconds (unsigned int)
MetaModel::Init_AddAttribute(new AttributeDuration('delete_policy_retention', [
'allowed_values' => null,
'sql' => 'delete_policy_retention',
'default_value' => null,
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeLinkedSet('attribute_list', [
'linked_class' => 'SynchroAttribute',
'ext_key_to_me' => 'sync_source_id',
'allowed_values' => null,
'count_min' => 0,
'count_max' => 0,
'depends_on' => [],
'tracking_level' => LINKSET_TRACKING_DETAILS,
]));
// Not used yet !
MetaModel::Init_AddAttribute(new AttributeEnum('user_delete_policy', [
'allowed_values' => new ValueSetEnum('everybody,administrators,nobody'),
'sql' => 'user_delete_policy',
'default_value' => 'nobody',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeURL('url_icon', [
'allowed_values' => null,
'sql' => 'url_icon',
'default_value' => null,
'is_null_allowed' => true,
'target' => '_top',
'depends_on' => [],
]));
// The field below is not a real URL since it can contain placeholders like $replica->primary_key$ which are not syntactically allowed in a real URL
MetaModel::Init_AddAttribute(new AttributeString('url_application', [
'allowed_values' => null,
'sql' => 'url_application',
'default_value' => null,
'is_null_allowed' => true,
'depends_on' => [],
]));
// Display lists
MetaModel::Init_SetZListItems(
'details',
[
'col:0' => [
'fieldset:SynchroDataSource:Description' => [
'name',
'description',
'status',
'scope_class',
'user_id',
'notify_contact_id',
'url_icon',
'url_application',
'database_table_name',
],
],
'col:1' => [
'fieldset:SynchroDataSource:Reconciliation' => [
'reconciliation_policy',
'action_on_zero',
'action_on_one',
'action_on_multiple',
],
'fieldset:SynchroDataSource:Deletion' => [
'user_delete_policy',
'full_load_periodicity',
'delete_policy',
'delete_policy_update',
'delete_policy_retention',
],
],
]
);
MetaModel::Init_SetZListItems(
'list',
['scope_class', 'status', 'user_id', 'full_load_periodicity']
); // Attributes to be displayed for a list
// Search criteria
MetaModel::Init_SetZListItems(
'standard_search',
['name', 'status', 'scope_class', 'user_id']
); // Criteria of the std search form
MetaModel::Init_SetZListItems('default_search', ['name', 'status', 'scope_class']); // Criteria of the defaut search form
// MetaModel::Init_SetZListItems('advanced_search', array('name')); // Criteria of the advanced search form
}
public function DisplayBareProperties(WebPage $oPage, $bEditMode = false, $sPrefix = '', $aExtraParams = [])
{
if (!$this->IsNew()) {
$this->Set('database_table_name', $this->GetDataTable());
}
return parent::DisplayBareProperties($oPage, $bEditMode, $sPrefix, $aExtraParams);
}
public function DisplayBareRelations(WebPage $oPage, $bEditMode = false)
{
if (!$this->IsNew()) {
$oPage->SetCurrentTab('Core:SynchroAttributes');
$oAttributeSet = $this->Get('attribute_list');
$aAttributes = [];
while ($oAttribute = $oAttributeSet->Fetch()) {
$aAttributes[$oAttribute->Get('attcode')] = $oAttribute;
}
// Columns of the form
$aAttribs = [];
foreach (['attcode', 'reconciliation', 'update', 'update_policy', 'reconciliation_attcode'] as $s) {
$aAttribs[$s] = ['label' => Dict::S("Core:SynchroAtt:$s"), 'description' => Dict::S("Core:SynchroAtt:$s+")];
}
// Rows of the form
$aValues = [];
foreach (MetaModel::ListAttributeDefs($this->GetTargetClass()) as $sAttCode => $oAttDef) {
if ($oAttDef->IsWritable()) {
if (isset($aAttributes[$sAttCode])) {
$oAttribute = $aAttributes[$sAttCode];
} else {
if ($oAttDef->IsExternalKey()) {
$oAttribute = new SynchroAttExtKey();
$oAttribute->Set('reconciliation_attcode', ''); // Blank means by pkey
} elseif ($oAttDef::IsLinkSet() && $oAttDef->IsIndirect()) {
$oAttribute = new SynchroAttLinkSet();
// Todo - add these settings into the form
$oAttribute->Set('row_separator', MetaModel::GetConfig()->Get('link_set_item_separator'));
$oAttribute->Set('attribute_separator', MetaModel::GetConfig()->Get('link_set_attribute_separator'));
$oAttribute->Set('value_separator', MetaModel::GetConfig()->Get('link_set_value_separator'));
$oAttribute->Set('attribute_qualifier', MetaModel::GetConfig()->Get('link_set_attribute_qualifier'));
} elseif ($oAttDef::IsScalar()) {
$oAttribute = new SynchroAttribute();
} else {
$oAttribute = null;
}
if ($oAttribute !== null) {
$oAttribute->Set('sync_source_id', $this->GetKey());
$oAttribute->Set('attcode', $sAttCode);
$oAttribute->Set('reconcile', MetaModel::IsReconcKey($this->GetTargetClass(), $sAttCode) ? 1 : 0);
$oAttribute->Set('update', 1);
$oAttribute->Set('update_policy', 'master_locked');
}
}
if ($oAttribute !== null) {
if (!$bEditMode) {
// Read-only mode
$aRow['reconciliation'] = $oAttribute->Get('reconcile') == 1 ? Dict::S('Core:SynchroReconcile:Yes') : Dict::S('Core:SynchroReconcile:No');
$aRow['update'] = $oAttribute->Get('update') == 1 ? Dict::S('Core:SynchroUpdate:Yes') : Dict::S('Core:SynchroUpdate:No');
$aRow['attcode'] = MetaModel::GetLabel(
$this->GetTargetClass(),
$oAttribute->Get('attcode')
).' ('.$oAttribute->Get('attcode').')';
$aRow['update_policy'] = $oAttribute->GetAsHTML('update_policy');
if ($oAttDef->IsExternalKey()) {
$sReconciliationAttCode = $oAttribute->Get('reconciliation_attcode');
switch ($sReconciliationAttCode) {
case '':
$sDisplayReconciliationAttCode = Dict::S('Core:SynchroAttExtKey:ReconciliationById');
break;
default:
$sDisplayReconciliationAttCode = MetaModel::GetLabel(
$oAttDef->GetTargetClass(),
$sReconciliationAttCode
);
}
$aRow['reconciliation_attcode'] = $sDisplayReconciliationAttCode;
} else {
$aRow['reconciliation_attcode'] = '&nbsp;';
}
} else {
// Edit mode
$sAttCode = $oAttribute->Get('attcode');
$sChecked = $oAttribute->Get('reconcile') == 1 ? 'checked' : '';
$aRow['reconciliation'] = "<input type=\"checkbox\" name=\"reconciliation[$sAttCode]\" $sChecked/>";
$sChecked = $oAttribute->Get('update') == 1 ? 'checked' : '';
$aRow['update'] = "<input type=\"checkbox\" name=\"update[$sAttCode]\" $sChecked/>";
$aRow['attcode'] = MetaModel::GetLabel(
$this->GetTargetClass(),
$oAttribute->Get('attcode')
).' ('.$oAttribute->Get('attcode').')';
$oUpdateAttDef = MetaModel::GetAttributeDef(get_class($oAttribute), 'update_policy');
$aRow['update_policy'] = cmdbAbstractObject::GetFormElementForField(
$oPage,
get_class($oAttribute),
'update_policy',
$oUpdateAttDef,
$oAttribute->Get('update_policy'),
'',
'update_policy_'.$sAttCode,
"[$sAttCode]"
);
if ($oAttDef->IsExternalKey()) {
$aRow['reconciliation_attcode'] = $oAttribute->GetReconciliationFormElement(
$oAttDef->GetTargetClass(),
"attr_reconciliation_attcode[$sAttCode]"
);
} else {
$aRow['reconciliation_attcode'] = '&nbsp;';
}
}
$aValues[] = $aRow;
}
}
}
$oPage->p(Dict::Format('Class:SynchroDataSource:DataTable', $this->GetDataTable()));
$oPage->Table($aAttribs, $aValues);
$this->DisplayStatusTab($oPage);
}
parent::DisplayBareRelations($oPage, $bEditMode);
}
/**
* Displays the status (SynchroLog) of the datasource in a graphical manner
*
* @param $oPage WebPage
*
* @return void
* @throws \CoreException
* @throws \CoreUnexpectedValue
* @throws \MissingQueryArgument
* @throws \MySQLException
* @throws \MySQLHasGoneAwayException
* @throws \OQLException
*/
protected function DisplayStatusTab(WebPage $oPage)
{
$oPage->SetCurrentTab('Core:SynchroStatus');
$sSelectSynchroLog = 'SELECT SynchroLog WHERE sync_source_id = :source_id';
$oSetSynchroLog = new CMDBObjectSet(
DBObjectSearch::FromOQL($sSelectSynchroLog),
['start_date' => false] /* order by*/,
['source_id' => $this->GetKey()]
);
$oSetSynchroLog->SetLimit(100); // Display only the 100 latest runs
if ($oSetSynchroLog->Count() > 0) {
$oLastLog = $oSetSynchroLog->Fetch();
$sStartDate = $oLastLog->GetAsHTML('start_date');
$oLastLog->Get('stats_nb_replica_seen');
$iLastLog = 0;
$iDSid = $this->GetKey();
if ($oLastLog->Get('status') === 'running') {
// Still running !
$oPage->p('<h2>'.Dict::Format('Core:Synchro:SynchroRunningStartedOn_Date', $sStartDate).'</h2>');
} else {
$sEndDate = $oLastLog->GetAsHTML('end_date');
$iLastLog = $oLastLog->GetKey();
$oPage->p('<h2>'.Dict::Format('Core:Synchro:SynchroEndedOn_Date', $sEndDate).'</h2>');
$sOQL = "SELECT SynchroReplica WHERE sync_source_id=$iDSid";
$oSet = new DBObjectSet(DBObjectSearch::FromOQL($sOQL));
$iCountAllReplicas = $oSet->Count();
$sAllReplicas = "<a href=\"../synchro/replica.php?operation=oql&datasource=$iDSid&oql=$sOQL\">$iCountAllReplicas</a>";
$sOQL = "SELECT SynchroReplica WHERE sync_source_id=$iDSid AND status_last_error !=''";
$oSet = new DBObjectSet(DBObjectSearch::FromOQL($sOQL));
$iCountAllErrors = $oSet->Count();
$sAllErrors = "<a href=\"../synchro/replica.php?operation=oql&datasource=$iDSid&oql=$sOQL\">$iCountAllErrors</a>";
$sOQL = "SELECT SynchroReplica WHERE sync_source_id=$iDSid AND status_last_warning !=''";
$oSet = new DBObjectSet(DBObjectSearch::FromOQL($sOQL));
$iCountAllWarnings = $oSet->Count();
$sAllWarnings = "<a href=\"../synchro/replica.php?operation=oql&datasource=$iDSid&oql=$sOQL\">$iCountAllWarnings</a>";
$oPage->p('<h2>'.Dict::Format(
'Core:Synchro:ListReplicas_AllReplicas_Errors_Warnings',
$sAllReplicas,
$sAllErrors,
$sAllWarnings
).'</h2>');
}
$oPage->add('<table class="synoptics"><tr><td>');
// List all the log entries for the user to select
$oPage->add('<h2 style="line-height:55px;">'.Dict::S('Core:Synchro:History').'</h2>');
$oSetSynchroLog->Rewind();
$oPage->add('<select size="25" onChange="UpdateSynoptics(this.value);">');
$sSelected = ' selected'; // First log is selected by default
$sScript = "var aSynchroLog = {\n";
while ($oLog = $oSetSynchroLog->Fetch()) {
$sLogTitle = Dict::Format('Core:SynchroLogTitle', $oLog->Get('status'), $oLog->GetEditValue('start_date'));
$oPage->add('<option value="'.$oLog->GetKey().'" '.$sSelected.'>'.$sLogTitle.'</option>');
$sSelected = ''; // only the first log is selected by default
$aData = $this->ProcessLog($oLog);
$sScript .= '"'.$oLog->GetKey().'": '.json_encode($aData).",\n";
}
$sScript .= "end: 'Done'";
$sScript .= "};\n";
$sScript .= <<<JS
var sLastLog = '$iLastLog';
function ToggleSynoptics(sId, bShow)
{
if (bShow)
{
$(sId).show();
}
else
{
$(sId).hide();
}
}
function UpdateSynoptics(id)
{
var aValues = aSynchroLog[id];
if (aValues == undefined) return;
for (var sKey in aValues)
{
$('#c_'+sKey).html(aValues[sKey]);
var fOpacity = (aValues[sKey] == 0) ? 0.3 : 1;
$('#'+sKey).fadeTo("slow", fOpacity);
}
//alert('id = '+id+', lastLog='+sLastLog+', id==sLastLog: '+(id==sLastLog)+' obj_updated_errors: '+aValues['obj_updated_errors']);
if ( (id == sLastLog) && (aValues['obj_new_errors'] > 0) )
{
$('#new_errors_link').show();
}
else
{
$('#new_errors_link').hide();
}
if ( (id == sLastLog) && (aValues['obj_updated_errors'] > 0) )
{
$('#updated_errors_link').show();
}
else
{
$('#updated_errors_link').hide();
}
if ( (id == sLastLog) && (aValues['obj_disappeared_errors'] > 0) )
{
$('#disappeared_errors_link').show();
}
else
{
$('#disappeared_errors_link').hide();
}
ToggleSynoptics('#cw_obj_created_warnings', aValues['obj_created_warnings'] > 0);
ToggleSynoptics('#cw_obj_new_updated_warnings', aValues['obj_new_updated_warnings'] > 0);
ToggleSynoptics('#cw_obj_new_unchanged_warnings', aValues['obj_new_unchanged_warnings'] > 0);
ToggleSynoptics('#cw_obj_updated_warnings', aValues['obj_updated_warnings'] > 0);
ToggleSynoptics('#cw_obj_unchanged_warnings', aValues['obj_unchanged_warnings'] > 0);
$('#status_traces').html(aValues['traces']);
}
JS;
$oPage->add_script($sScript);
$oPage->add('</select>');
$oPage->add('</td><td style="vertical-align:top;">');
// Now build the big "synoptics" view
$aData = $this->ProcessLog($oLastLog);
$sNbReplica = '<img src="'.$this->GetIcon(false).'" class="ibo-class-icon ibo-is-medium" style="vertical-align:middle;">&nbsp;'.Dict::Format(
'Core:Synchro:Nb_Replica',
"<span id=\"c_nb_replica_total\">{$aData['nb_replica_total']}</span>"
);
$sNbObjects = '<img src="'.MetaModel::GetClassIcon($this->GetTargetClass(), false).'" class="ibo-class-icon ibo-is-medium" style="vertical-align:middle;">&nbsp;'.Dict::Format(
'Core:Synchro:Nb_Class:Objects',
$this->GetTargetClass(),
"<span id=\"c_nb_obj_total\">{$aData['nb_obj_total']}</span>"
);
$oPage->add(
<<<EOF
<table class="synoptics">
<tr class="synoptics_header">
<td>$sNbReplica</td><td>&nbsp;</td><td>$sNbObjects</td>
</tr>
<tr>
EOF
);
$sBaseOQL = 'SELECT SynchroReplica WHERE sync_source_id='.$this->GetKey()." AND status_last_error!=''";
$oPage->add($this->HtmlBox('repl_ignored', $aData, 'grey', '', '', 'ibo-data-synchro-source--replicas-status-separator').'<td colspan="2">&nbsp;</td>');
$oPage->add("</tr>\n<tr>");
$oPage->add($this->HtmlBox(
'repl_disappeared',
$aData,
'orange',
'rowspan="4"',
'',
'ibo-data-synchro-source--replicas-status-separator'
).'<td rowspan="4" class="arrow"><i class="fas fa-arrow-right"></i></td>'.$this->HtmlBox('obj_disappeared_no_action', $aData, 'grey', '', '', 'ibo-data-synchro-source--replicas-status-separator'));
$oPage->add("</tr>\n<tr>");
$oPage->add($this->HtmlBox('obj_deleted', $aData, 'bluegrey'));
$oPage->add("</tr>\n<tr>");
$oPage->add($this->HtmlBox('obj_obsoleted', $aData, 'orange'));
$oPage->add("</tr>\n<tr>");
$sOQL = urlencode($sBaseOQL." AND status='obsolete'");
$oPage->add($this->HtmlBox(
'obj_disappeared_errors',
$aData,
'red',
'',
" <a style=\"color:#fff\" href=\"../synchro/replica.php?operation=oql&datasource=$iDSid&oql=$sOQL\" id=\"disappeared_errors_link\">Show</a>"
));
$oPage->add("</tr>\n<tr>");
$oPage->add($this->HtmlBox(
'repl_existing',
$aData,
'green',
'rowspan="3"',
'',
'ibo-data-synchro-source--replicas-status-separator'
).'<td rowspan="3" class="arrow"><i class="fas fa-arrow-right"></i></td>'.$this->HtmlBox('obj_unchanged', $aData, 'blue', '', '', 'ibo-data-synchro-source--replicas-status-separator'));
$oPage->add("</tr>\n<tr>");
$oPage->add($this->HtmlBox('obj_updated', $aData, 'green'));
$oPage->add("</tr>\n<tr>");
$sOQL = urlencode($sBaseOQL." AND status='modified'");
$oPage->add($this->HtmlBox(
'obj_updated_errors',
$aData,
'red',
'',
" <a style=\"color:#fff\" href=\"../synchro/replica.php?operation=oql&datasource=$iDSid&oql=$sOQL\" id=\"updated_errors_link\">Show</a>"
));
$oPage->add("</tr>\n<tr>");
$oPage->add($this->HtmlBox(
'repl_new',
$aData,
'cyan',
'rowspan="4"',
'',
'ibo-data-synchro-source--replicas-status-separator'
).'<td rowspan="4" class="arrow"><i class="fas fa-arrow-right"></i></td>'.$this->HtmlBox('obj_new_unchanged', $aData, 'blue', '', '', 'ibo-data-synchro-source--replicas-status-separator'));
$oPage->add("</tr>\n<tr>");
$oPage->add($this->HtmlBox('obj_new_updated', $aData, 'green'));
$oPage->add("</tr>\n<tr>");
$oPage->add($this->HtmlBox('obj_created', $aData, 'cyan'));
$oPage->add("</tr>\n<tr>");
$sOQL = urlencode($sBaseOQL." AND status='new'");
$oPage->add($this->HtmlBox(
'obj_new_errors',
$aData,
'red',
'',
" <a style=\"color:#fff\" href=\"../synchro/replica.php?operation=oql&datasource=$iDSid&oql=$sOQL\" id=\"new_errors_link\">Show</a>"
));
$oPage->add("</tr>\n</table>\n");
$oPage->add('</td></tr></table>');
$oPage->add('<div id="status_traces" style="overflow-x:auto"></div>');
$oPage->add_ready_script("UpdateSynoptics('$iLastLog')");
} else {
$oPage->p('<h2>'.Dict::S('Core:Synchro:NeverRun').'</h2>');
}
}
protected function HtmlBox($sId, $aData, $sColor, $sHTMLAttribs = '', $sErrorLink = '', $sAdditionalCss = "")
{
$iCount = $aData[$sId];
$sCount = "<span id=\"c_{$sId}\">$iCount</span>";
$sLabel = Dict::Format('Core:Synchro:label_'.$sId, $sCount);
$sOpacity = ($iCount == 0) ? 'ibo-is-light' : '';
if (isset($aData[$sId.'_warnings'])) {
$sLabel .= " <span id=\"cw_{$sId}_warnings\" class=\"ibo-data-synchro-source--replicas-status--warning\"><i class=\"fas fa-exclamation-triangle\"></i> (<span id=\"c_{$sId}_warnings\">".$aData[$sId.'_warnings'].'</span>)</span>';
}
return '<td id="'.$sId.'" class="ibo-data-synchro-source--replicas-status ibo-is-'.$sColor.' '.$sOpacity.' '.$sAdditionalCss.'" '.$sHTMLAttribs.'>'.$sLabel.$sErrorLink.'</td>';
}
protected function ProcessLog($oLastLog)
{
$aData = [
'obj_deleted' => $oLastLog->Get('stats_nb_obj_deleted'),
'obj_obsoleted' => $oLastLog->Get('stats_nb_obj_obsoleted'),
'obj_disappeared_errors' => $oLastLog->Get('stats_nb_obj_obsoleted_errors') + $oLastLog->Get('stats_nb_obj_deleted_errors'),
'obj_disappeared_no_action' => $oLastLog->Get('stats_nb_replica_disappeared_no_action'),
'obj_updated' => $oLastLog->Get('stats_nb_obj_updated'),
'obj_updated_warnings' => $oLastLog->Get('stats_nb_obj_updated_warnings'),
'obj_updated_errors' => $oLastLog->Get('stats_nb_obj_updated_errors'),
'obj_new_updated' => $oLastLog->Get('stats_nb_obj_new_updated'),
'obj_new_updated_warnings' => $oLastLog->Get('stats_nb_obj_new_updated_warnings'),
'obj_new_unchanged' => $oLastLog->Get('stats_nb_obj_new_unchanged'),
'obj_created' => $oLastLog->Get('stats_nb_obj_created'),
'obj_created_warnings' => $oLastLog->Get('stats_nb_obj_created_warnings'),
'obj_created_errors' => $oLastLog->Get('stats_nb_obj_created_errors'),
'obj_unchanged_warnings' => $oLastLog->Get('stats_nb_obj_unchanged_warnings'),
];
$oLastLog->Get('stats_nb_replica_reconciled_errors');
$iDisappeared = $aData['obj_disappeared_errors'] + $aData['obj_obsoleted'] + $aData['obj_deleted'] + $aData['obj_disappeared_no_action'];
$aData['repl_disappeared'] = $iDisappeared;
$iNewErrors = $aData['obj_created_errors'] + $oLastLog->Get('stats_nb_replica_reconciled_errors');
$aData['obj_new_errors'] = $iNewErrors;
$iNew = $aData['obj_created'] + $iNewErrors + $aData['obj_new_updated'] + $aData['obj_new_unchanged'];
$aData['repl_new'] = $iNew;
$iExisting = $oLastLog->Get('stats_nb_replica_seen') - $iNew;
$aData['repl_existing'] = $iExisting;
$aData['obj_unchanged'] = $iExisting - $aData['obj_updated'] - $aData['obj_updated_errors'];
$iIgnored = $oLastLog->Get('stats_nb_replica_total') - $iNew - $iExisting - $iDisappeared;
$aData['repl_ignored'] = $iIgnored;
$aData['nb_obj_total'] = $iNew + $iExisting + $iDisappeared;
$aData['nb_replica_total'] = $aData['nb_obj_total'] + $iIgnored;
if (strlen($oLastLog->Get('traces')) > 0) {
$aData['traces'] = '<fieldset class="ibo-fieldset"><legend class="ibo-fieldset-legend">Debug traces</legend><pre>'.utils::EscapeHtml($oLastLog->Get('traces')).'</pre></fieldset>';
} else {
$aData['traces'] = '';
}
return $aData;
}
public function GetIcon($bImgTag = true, $sMoreStyles = '')
{
if ($this->Get('url_icon') == '') {
return MetaModel::GetClassIcon(get_class($this), $bImgTag);
}
if ($bImgTag) {
return '<img src="'.$this->Get('url_icon')."\" style=\"vertical-align:middle;$sMoreStyles\"/>";
}
return $this->Get('url_icon');
}
/**
* Get the actual hyperlink to the remote application for the given replica and dest object
*
* @param \DBObject $oDestObj
* @param \SynchroReplica $oReplica
*
* @return string
*/
public function GetApplicationUrl(DBObject $oDestObj, SynchroReplica $oReplica)
{
if ($this->Get('url_application') == '') {
return '';
}
$aSearches = [];
$aReplacements = [];
foreach (MetaModel::ListAttributeDefs($this->GetTargetClass()) as $sAttCode => $oAttDef) {
if ($oAttDef->IsScalar()) {
$aSearches[] = '$this->'.$sAttCode.'$';
$aReplacements[] = $oDestObj->Get($sAttCode);
}
}
$aData = $oReplica->LoadExtendedDataFromTable($this->GetDataTable());
foreach ($aData as $sColumn => $value) {
$aSearches[] = '$replica->'.$sColumn.'$';
$aReplacements[] = $value;
}
return str_replace($aSearches, $aReplacements, $this->Get('url_application'));
}
public function GetAttributeFlags($sAttCode, &$aReasons = [], $sTargetState = '')
{
if ((($sAttCode == 'scope_class') || ($sAttCode == 'database_table_name')) && (!$this->IsNew())) {
return OPT_ATT_READONLY;
}
return parent::GetAttributeFlags($sAttCode, $aReasons, $sTargetState);
}
public function UpdateObjectFromPostedForm($sFormPrefix = '', $sAttList = null, $aAttFlags = [])
{
parent::UpdateObjectFromPostedForm($sFormPrefix, $sAttList, $aAttFlags);
// And now read the other post parameters...
$oAttributeSet = $this->Get('attribute_list');
$aAttributes = [];
while ($oAttribute = $oAttributeSet->Fetch()) {
$aAttributes[$oAttribute->Get('attcode')] = $oAttribute;
}
$aReconcile = utils::ReadPostedParam('reconciliation', []);
$aUpdate = utils::ReadPostedParam('update', []);
$aUpdatePolicy = utils::ReadPostedParam('attr_update_policy', []);
$aReconciliation = utils::ReadPostedParam('attr_reconciliation_attcode', []);
// update_policy cannot be empty, so there is one entry per attribute, use this to iterate
// through all the writable attributes
foreach ($aUpdatePolicy as $sAttCode => $sValue) {
if (!isset($aAttributes[$sAttCode])) {
$oAttribute = $this->CreateSynchroAtt($sAttCode);
} else {
$oAttribute = $aAttributes[$sAttCode];
}
$bReconcile = 0;
if (isset($aReconcile[$sAttCode])) {
$bReconcile = $aReconcile[$sAttCode] == 'on' ? 1 : 0;
}
$bUpdate = 0; // Default / initial value
if (isset($aUpdate[$sAttCode])) {
$bUpdate = $aUpdate[$sAttCode] == 'on' ? 1 : 0;
}
$oAttribute->Set('reconcile', $bReconcile);
$oAttribute->Set('update', $bUpdate);
$oAttribute->Set('update_policy', $sValue);
if ($oAttribute instanceof SynchroAttExtKey) {
$oAttribute->Set('reconciliation_attcode', $aReconciliation[$sAttCode]);
} elseif ($oAttribute instanceof SynchroAttLinkSet) {
// Do nothing for now...
}
$oAttributeSet->AddItem($oAttribute);
}
$this->Set('attribute_list', $oAttributeSet);
}
/**
* Creates a new SynchroAttXXX object in memory with the default values
*
* @param string $sAttCode
*
* @return \SynchroAttExtKey|\SynchroAttLinkSet|\SynchroAttribute
*/
protected function CreateSynchroAtt($sAttCode)
{
$oAttDef = MetaModel::GetAttributeDef($this->GetTargetClass(), $sAttCode);
if ($oAttDef->IsExternalKey()) {
$oAttribute = new SynchroAttExtKey();
$oAttribute->Set('reconciliation_attcode', ''); // Blank means by pkey
} elseif ($oAttDef->IsLinkSet() && $oAttDef->IsIndirect()) {
$oAttribute = new SynchroAttLinkSet();
// Todo - set those value from the form
$oAttribute->Set('row_separator', MetaModel::GetConfig()->Get('link_set_item_separator'));
$oAttribute->Set('attribute_separator', MetaModel::GetConfig()->Get('link_set_attribute_separator'));
$oAttribute->Set('value_separator', MetaModel::GetConfig()->Get('link_set_value_separator'));
$oAttribute->Set('attribute_qualifier', MetaModel::GetConfig()->Get('link_set_attribute_qualifier'));
} else {
$oAttribute = new SynchroAttribute();
}
$oAttribute->Set('sync_source_id', $this->GetKey());
$oAttribute->Set('attcode', $sAttCode);
$oAttribute->Set('reconcile', 0);
$oAttribute->Set('update', 0);
$oAttribute->Set('update_policy', 'master_locked');
return $oAttribute;
}
/**
* Overload the standard behavior
*/
public function ComputeValues()
{
parent::ComputeValues();
if ($this->IsNew()) {
// Compute the database_table_name
$sDataTable = $this->Get('database_table_name');
if (!empty($sDataTable)) {
$this->Set('database_table_name', $this->ComputeDataTableName());
}
// When inserting a new datasource object, also create the SynchroAttribute objects
// for each field of the target class
// Create all the SynchroAttribute records
$oAttributeSet = $this->Get('attribute_list');
if ($oAttributeSet->Count() == 0) {
foreach (MetaModel::ListAttributeDefs($this->GetTargetClass()) as $sAttCode => $oAttDef) {
if ($oAttDef->IsWritable()) {
$oAttDef = MetaModel::GetAttributeDef($this->GetTargetClass(), $sAttCode);
if ($oAttDef->IsExternalKey()) {
$oAttribute = new SynchroAttExtKey();
$oAttribute->Set('reconciliation_attcode', ''); // Blank means by pkey
} elseif ($oAttDef->IsLinkSet() && $oAttDef->IsIndirect()) {
$oAttribute = new SynchroAttLinkSet();
// Todo - set those value from the form
$oAttribute->Set('row_separator', MetaModel::GetConfig()->Get('link_set_item_separator'));
$oAttribute->Set('attribute_separator', MetaModel::GetConfig()->Get('link_set_attribute_separator'));
$oAttribute->Set('value_separator', MetaModel::GetConfig()->Get('link_set_value_separator'));
$oAttribute->Set('attribute_qualifier', MetaModel::GetConfig()->Get('link_set_attribute_qualifier'));
} elseif ($oAttDef->IsScalar()) {
$oAttribute = new SynchroAttribute();
} else {
$oAttribute = null;
}
if (!is_null($oAttribute)) {
$oAttribute->Set('attcode', $sAttCode);
$oAttribute->Set('reconcile', MetaModel::IsReconcKey($this->GetTargetClass(), $sAttCode) ? 1 : 0);
$oAttribute->Set('update', 1);
$oAttribute->Set('update_policy', 'master_locked');
$oAttributeSet->AddItem($oAttribute);
}
}
}
$this->Set('attribute_list', $oAttributeSet);
}
} else {
$sDataTable = $this->Get('database_table_name');
if (empty($sDataTable)) {
$this->Set('database_table_name', $this->ComputeDataTableName());
}
}
}
public function DoCheckToWrite()
{
parent::DoCheckToWrite();
// Check that there is at least one reconciliation key defined
if ($this->Get('reconciliation_policy') == 'use_attributes') {
$oSet = $this->Get('attribute_list');
$bReconciliationKey = false;
foreach ($oSet as $oSynchroAttribute) {
if ($oSynchroAttribute->Get('reconcile') == 1) {
$bReconciliationKey = true; // At least one key is defined
break;
}
}
if (!$bReconciliationKey) {
$this->m_aCheckIssues[] = Dict::Format('Class:SynchroDataSource/Error:AtLeastOneReconciliationKeyMustBeSpecified');
}
}
// If 'update_then_delete' is specified there must be a delete_retention_period
if (($this->Get('delete_policy') == 'update_then_delete') && ($this->Get('delete_policy_retention') == 0)) {
$this->m_aCheckIssues[] = Dict::Format('Class:SynchroDataSource/Error:DeleteRetentionDurationMustBeSpecified');
}
// If update is specified, then something to update must be defined
if ((($this->Get('delete_policy') == 'update_then_delete') || ($this->Get('delete_policy') == 'update'))
&& ($this->Get('delete_policy_update') == '')) {
$this->m_aCheckIssues[] = Dict::Format('Class:SynchroDataSource/Error:DeletePolicyUpdateMustBeSpecified');
}
// When creating the data source with a specified database_table_name, this table must NOT exist
if ($this->IsNew()) {
$sDataTable = $this->GetDataTable();
if (!empty($sDataTable) && CMDBSource::IsTable($this->GetDataTable())) {
// Hmm, the synchro_data_xxx table already exists !!
$this->m_aCheckIssues[] = Dict::Format('Class:SynchroDataSource/Error:DataTableAlreadyExists', $this->GetDataTable());
}
}
}
public function GetTargetClass()
{
return $this->Get('scope_class');
}
public function GetDataTable()
{
$sTable = $this->Get('database_table_name');
if (empty($sTable)) {
$sTable = $this->ComputeDataTableName();
}
return $sTable;
}
protected function ComputeDataTableName()
{
$sDBTableName = $this->Get('database_table_name');
if (empty($sDBTableName)) {
$sDBTableName = strtolower($this->GetTargetClass());
$sDBTableName = preg_replace('/[^A-za-z0-9_]/', '_', $sDBTableName); // Remove forbidden characters from the table name
$sDBTableName .= '_'.$this->GetKey(); // Add a suffix for unicity
} else {
$sDBTableName = preg_replace('/[^A-za-z0-9_]/', '_', $sDBTableName); // Remove forbidden characters from the table name
}
$sPrefix = MetaModel::GetConfig()->Get('db_subname').'synchro_data_';
if (strpos($sDBTableName, $sPrefix) !== 0) {
$sDBTableName = $sPrefix.$sDBTableName;
}
return $sDBTableName;
}
/**
* When the new datasource has been created, let's create the synchro_data table
* that will hold the data records and the correspoding triggers which will maintain
* both tables in sync
*/
protected function AfterInsert()
{
parent::AfterInsert();
$sTable = $this->GetDataTable();
$aColumns = $this->GetSQLColumns();
$aFieldDefs = [];
// Allow '0', otherwise mysql will render an error when the id is not given
// (the trigger is expected to set the value, but it is not executed soon enough)
$aFieldDefs[] = 'id INTEGER(11) NOT NULL DEFAULT 0 ';
$aFieldDefs[] = '`primary_key` VARCHAR(255) NULL DEFAULT NULL';
foreach ($aColumns as $sColumn => $ColSpec) {
$aFieldDefs[] = "`$sColumn` $ColSpec NULL DEFAULT NULL";
}
$aFieldDefs[] = 'INDEX (id)';
$aFieldDefs[] = 'INDEX (primary_key)';
$sFieldDefs = implode(', ', $aFieldDefs);
$sDbCharset = DEFAULT_CHARACTER_SET;
$sDbCollation = DEFAULT_COLLATION;
$sCreateTable = "CREATE TABLE `$sTable` ($sFieldDefs) ENGINE = ".MYSQL_ENGINE.' CHARACTER SET '.$sDbCharset.' COLLATE '.$sDbCollation.';';
CMDBSource::Query($sCreateTable);
$aTriggers = $this->GetTriggersDefinition();
foreach ($aTriggers as $key => $sTriggerSQL) {
CMDBSource::Query($sTriggerSQL);
}
$sDataTable = $this->Get('database_table_name');
if (empty($sDataTable)) {
$this->Set('database_table_name', $this->ComputeDataTableName());
$this->DBUpdate();
}
}
/**
* Gets the definitions of the 3 triggers: before insert, before update and after delete
*
* @return array An array with 3 entries, one for each of the SQL queries
*/
protected function GetTriggersDefinition()
{
$sTable = $this->GetDataTable();
$sReplicaTable = MetaModel::DBGetTable('SynchroReplica');
$aColumns = $this->GetSQLColumns();
$aResult = [];
$sTriggerInsert = "CREATE TRIGGER `{$sTable}_bi` BEFORE INSERT ON `$sTable`";
$sTriggerInsert .= ' FOR EACH ROW';
$sTriggerInsert .= ' BEGIN';
$sTriggerInsert .= " INSERT INTO `{$sReplicaTable}` (`sync_source_id`, `status_last_seen`, `status`) VALUES ({$this->GetKey()}, NOW(), 'new');";
$sTriggerInsert .= ' SET NEW.id = LAST_INSERT_ID();';
$sTriggerInsert .= ' END;';
$aResult['bi'] = $sTriggerInsert;
$aModified = [];
foreach ($aColumns as $sColumn => $ColSpec) {
// <=> is a null-safe 'EQUALS' operator (there is no equivalent for "DIFFERS FROM")
$aModified[] = "NOT(NEW.`$sColumn` <=> OLD.`$sColumn`)";
}
$sIsModified = '('.implode(') OR (', $aModified).')';
// Update the replica
//
// status is forced to "new" if the replica was obsoleted directly from the state "new" (dest_id = null)
// otherwise, if status was either 'obsolete' or 'synchronized' it is turned into 'modified' or 'synchronized' depending on the changes
// otherwise, the status is left as is
$sTriggerUpdate = "CREATE TRIGGER `{$sTable}_bu` BEFORE UPDATE ON `$sTable`";
$sTriggerUpdate .= ' FOR EACH ROW';
$sTriggerUpdate .= ' BEGIN';
$sTriggerUpdate .= ' IF @itopuser is null THEN';
$sTriggerUpdate .= " UPDATE `{$sReplicaTable}` SET status_last_seen = NOW(), `status` = IF(`status` = 'obsolete', IF(`dest_id` IS NULL, 'new', 'modified'), IF(`status` IN ('synchronized') AND ($sIsModified), 'modified', `status`)) WHERE sync_source_id = {$this->GetKey()} AND id = OLD.id;";
$sTriggerUpdate .= ' SET NEW.id = OLD.id;'; // make sure this id won't change
$sTriggerUpdate .= ' END IF;';
$sTriggerUpdate .= ' END;';
$aResult['bu'] = $sTriggerUpdate;
$sTriggerDelete = "CREATE TRIGGER `{$sTable}_ad` AFTER DELETE ON `$sTable`";
$sTriggerDelete .= ' FOR EACH ROW';
$sTriggerDelete .= ' BEGIN';
$sTriggerDelete .= " DELETE FROM `{$sReplicaTable}` WHERE id = OLD.id;";
$sTriggerDelete .= ' END;';
$aResult['ad'] = $sTriggerDelete;
return $aResult;
}
protected function AfterDelete()
{
parent::AfterDelete();
$sTable = $this->GetDataTable();
$sDropTable = "DROP TABLE IF EXISTS `$sTable`"; // Do not fail if the table is already deleted (corrupted database)
CMDBSource::Query($sDropTable);
// TO DO - check that triggers get dropped with the table
$sSyncReplicaTable = MetaModel::DBGetTable(SynchroReplica::class);
$sSyncSourceIDColumn = MetaModel::GetAttributeDef(SynchroReplica::class, 'sync_source_id');
$sSqlDeleteReplica = "DELETE FROM `$sSyncReplicaTable` WHERE {$sSyncSourceIDColumn->Get('sql')} = '{$this->GetKey()}'";
CMDBSource::Query($sSqlDeleteReplica);
}
/**
* Checks if the data source definition is consistent with the schema of the target class
*
* @param boolean $bDiagnostics boolean True to only diagnose the consistency, false to actually apply some changes
* @param boolean $bVerbose boolean True to get some information in the std output (echo)
* @param null $oChange //FIXME never used, should we drop this ?
*
* @return bool Whether or not the database needs fixing for this data source
*/
public function CheckDBConsistency($bDiagnostics, $bVerbose, $oChange = null)
{
$bFixNeeded = false;
$bTriggerRebuildNeeded = false;
$aMissingFields = [];
$oAttributeSet = $this->Get('attribute_list');
$aAttributes = [];
while ($oAttribute = $oAttributeSet->Fetch()) {
$sAttCode = $oAttribute->Get('attcode');
if (MetaModel::IsValidAttCode($this->GetTargetClass(), $sAttCode)) {
$aAttributes[$sAttCode] = $oAttribute;
} else {
// Old field remaining
$bTriggerRebuildNeeded = true;
if ($bVerbose) {
echo "Irrelevant field description for the field '$sAttCode', for the data synchro task ".$this->GetName().' ('.$this->GetKey()."), will be removed.\n";
}
$bFixNeeded = true;
if (!$bDiagnostics) {
// Fix the issue
$oAttribute->DBDelete();
}
}
}
$sTable = $this->GetDataTable();
foreach ($this->ListTargetAttributes() as $sAttCode => $oAttDef) {
if (!isset($aAttributes[$sAttCode])) {
$bFixNeeded = true;
$aMissingFields[] = $sAttCode;
$bTriggerRebuildNeeded = true;
// New field missing...
if ($bVerbose) {
echo "Missing field description for the field '$sAttCode', for the data synchro task ".$this->GetName().' ('.$this->GetKey()."), will be created with default values.\n";
}
if (!$bDiagnostics) {
// Fix the issue
$oAttribute = $this->CreateSynchroAtt($sAttCode);
$oAttribute->DBInsert();
}
} else {
$aColumns = $this->GetSQLColumns([$sAttCode]);
foreach ($aColumns as $sColName => $sColumnDef) {
$bOneColIsMissing = false;
if (!CMDBSource::IsField($sTable, $sColName)) {
$bFixNeeded = true;
$bOneColIsMissing = true;
if ($bVerbose) {
if (count($aColumns) > 1) {
echo "Missing column '$sColName', in the table '$sTable' for the data synchro task ".$this->GetName().' ('.$this->GetKey()."). The columns '".implode(
"', '",
$aColumns
)." will be added.'.\n";
} else {
echo "Missing column '$sColName', in the table '$sTable' for the data synchro task ".$this->GetName().' ('.$this->GetKey()."). The column '$sColName' will be added.\n";
}
}
} elseif (!CMDBSource::IsSameFieldTypes($sColumnDef, CMDBSource::GetFieldSpec($sTable, $sColName))) {
$bFixNeeded = true;
$bOneColIsMissing = true;
if (count($aColumns) > 1) {
echo "Incorrect column '$sColName' (".CMDBSource::GetFieldSpec(
$sTable,
$sColName
).' instead of '.$sColumnDef."), in the table '$sTable' for the data synchro task ".$this->GetName().' ('.$this->GetKey()."). The columns '".implode(
"', '",
$aColumns
)." will be re-created.'.\n";
} else {
echo "Incorrect column '$sColName' (".CMDBSource::GetFieldSpec(
$sTable,
$sColName
).' instead of '.$sColumnDef."), in the table '$sTable' for the data synchro task ".$this->GetName().' ('.$this->GetKey()."). The column '$sColName' will be re-created.\n";
}
}
if ($bOneColIsMissing) {
$bTriggerRebuildNeeded = true;
$aMissingFields[] = $sAttCode;
}
}
}
}
$sDBName = MetaModel::GetConfig()->Get('db_name');
try {
// Note: as per the MySQL documentation, using information_schema behaves exactly like SHOW TRIGGERS (user privileges)
// and this is in fact the recommended way for better portability
$iTriggerCount = CMDBSource::QueryToScalar("select count(*) from information_schema.triggers where EVENT_OBJECT_SCHEMA='$sDBName' and EVENT_OBJECT_TABLE='$sTable'");
} catch (Exception $e) {
if ($bVerbose) {
echo 'Failed to investigate on the synchro triggers (skipping the check): '.$e->getMessage().".\n";
}
// Ignore this error: consider that the trigger are there
$iTriggerCount = 3;
}
if ($iTriggerCount < 3) {
$bFixNeeded = true;
$bTriggerRebuildNeeded = true;
if ($bVerbose) {
echo 'Missing trigger(s) for the data synchro task '.$this->GetName()." (table {$sTable}).\n";
}
}
$aRepairQueries = [];
if (count($aMissingFields) > 0) {
// The structure of the table needs adjusting
$aColumns = $this->GetSQLColumns($aMissingFields);
$aFieldDefs = [];
foreach ($aColumns as $sAttCode => $sColumnDef) {
if (CMDBSource::IsField($sTable, $sAttCode)) {
$aRepairQueries[] = "ALTER TABLE `$sTable` CHANGE `$sAttCode` `$sAttCode` $sColumnDef";
} else {
$aFieldDefs[] = "`$sAttCode` $sColumnDef";
}
}
if (count($aFieldDefs) > 0) {
$aRepairQueries[] = "ALTER TABLE `$sTable` ADD (".implode(',', $aFieldDefs).');';
}
if ($bDiagnostics) {
if ($bVerbose) {
echo "The structure of the table $sTable for the data synchro task ".$this->GetName().' ('.$this->GetKey().') must be altered (missing or incorrect fields: '.implode(
', ',
$aMissingFields
).").\n";
}
}
}
// Repair the triggers
// Must be done after updating the columns because MySQL does check the validity of the query found into the procedure!
if ($bTriggerRebuildNeeded) {
// The triggers as well must be adjusted
$aTriggersDefs = $this->GetTriggersDefinition();
$aTriggerRepair = [];
$aTriggerRepair[] = "DROP TRIGGER IF EXISTS `{$sTable}_bi`;";
$aTriggerRepair[] = $aTriggersDefs['bi'];
$aTriggerRepair[] = "DROP TRIGGER IF EXISTS `{$sTable}_bu`;";
$aTriggerRepair[] = $aTriggersDefs['bu'];
$aTriggerRepair[] = "DROP TRIGGER IF EXISTS `{$sTable}_ad`;";
$aTriggerRepair[] = $aTriggersDefs['ad'];
if ($bDiagnostics) {
if ($bVerbose) {
echo "The triggers {$sTable}_bi, {$sTable}_bu, {$sTable}_ad for the data synchro task ".$this->GetName().' ('.$this->GetKey().") must be re-created.\n";
echo implode("\n", $aTriggerRepair)."\n";
}
}
$aRepairQueries = array_merge($aRepairQueries, $aTriggerRepair); // The order matters!
}
// Execute the repair statements
//
if (!$bDiagnostics && (count($aRepairQueries) > 0)) {
// Fix the issue
foreach ($aRepairQueries as $sSQL) {
CMDBSource::Query($sSQL);
if ($bVerbose) {
echo "$sSQL\n";
}
}
}
return $bFixNeeded;
}
public function SendNotification($sSubject, $sBody)
{
$iContact = $this->Get('notify_contact_id');
if ($iContact == 0) {
// Leave silently...
return;
}
$oContact = MetaModel::GetObject('Contact', $iContact);
// Determine the email attribute (the first one will be our choice)
$sEmailAttCode = null;
foreach (MetaModel::ListAttributeDefs(get_class($oContact)) as $sAttCode => $oAttDef) {
if ($oAttDef instanceof AttributeEmailAddress) {
$sEmailAttCode = $sAttCode;
// we've got one, exit the loop
break;
}
}
if (is_null($sEmailAttCode)) {
// Leave silently...
return;
}
$sTo = $oContact->Get($sEmailAttCode);
$sBody = '<p>Data synchronization: '.$this->GetHyperlink().'</p>'.$sBody;
$sSubject = 'iTop Data Sync - '.$this->GetName().' - '.$sSubject;
$oEmail = new Email();
$oEmail->SetRecipientTO($sTo);
$oEmail->SetSubject($sSubject);
$oEmail->SetBody($sBody);
if ($oEmail->Send($aIssues) == EMAIL_SEND_ERROR) {
// mmmm, what can I do?
}
}
/**
* Get the list of attributes eligible to the synchronization
*/
public function ListTargetAttributes()
{
$aRet = [];
foreach (MetaModel::ListAttributeDefs($this->GetTargetClass()) as $sAttCode => $oAttDef) {
if ($sAttCode == 'finalclass') {
continue;
}
if (!$oAttDef->IsWritable()) {
continue;
}
if ($oAttDef->IsLinkSet() && !$oAttDef->IsIndirect()) {
continue;
}
$aRet[$sAttCode] = $oAttDef;
}
return $aRet;
}
/**
* @param null|string[] $aAttributeCodes attribute codes list
*
* @return string[] corresponding current class SQL columns, all of the table columns if null was provided
*/
public function GetSQLColumns($aAttributeCodes = null)
{
$aColumns = [];
$sClass = $this->GetTargetClass();
if (is_null($aAttributeCodes)) {
$aAttributeCodes = [];
foreach ($this->ListTargetAttributes() as $sAttCode => $oAttDef) {
$aAttributeCodes[] = $sAttCode;
}
}
foreach ($aAttributeCodes as $sAttCode) {
$oAttDef = MetaModel::GetAttributeDef($sClass, $sAttCode);
if ($oAttDef->IsExternalKey()) {
// The pkey might be used as well as any other key column
$aColumns[$sAttCode] = 'VARCHAR(255)'.CMDBSource::GetSqlStringColumnDefinition();
} else {
if (is_iterable($oAttDef->GetImportColumns())) {
foreach ($oAttDef->GetImportColumns() as $sField => $sDBFieldType) {
$aColumns[$sField] = $sDBFieldType;
}
}
}
}
return $aColumns;
}
/**
* DEPRECATED - Get the list of Date and Datetime SQL columns
*/
public function GetDateSQLColumns()
{
$aDateAttributes = [];
$sClass = $this->GetTargetClass();
foreach (MetaModel::ListAttributeDefs($sClass) as $sAttCode => $oAttDef) {
if ($oAttDef instanceof AttributeDateTime) {
$aDateAttributes[] = $sAttCode;
}
}
return $this->GetSQLColumns($aDateAttributes);
}
public function IsRunning()
{
$sOQL = "SELECT SynchroLog WHERE sync_source_id = :source_id AND status='running'";
$oSet = new DBObjectSet(
DBObjectSearch::FromOQL($sOQL),
['start_date' => false] /* order by*/,
['source_id' => $this->GetKey()] /* aArgs */,
[],
1 /* limitCount */,
0 /* limitStart */
);
if ($oSet->Count() < 1) {
$bRet = false;
} else {
$bRet = true;
}
return $bRet;
}
public function GetLatestLog()
{
$oLog = null;
$sOQL = 'SELECT SynchroLog WHERE sync_source_id = :source_id';
$oSet = new DBObjectSet(
DBObjectSearch::FromOQL($sOQL),
['start_date' => false] /* order by*/,
['source_id' => $this->GetKey()] /* aArgs */,
[],
1 /* limitCount */,
0 /* limitStart */
);
if ($oSet->Count() >= 1) {
$oLog = $oSet->Fetch();
}
return $oLog;
}
// TO DO: remove if still unused
/**
* Retrieve from the log, the date of the last completed import
*
* @return DateTime
*/
public function GetLastCompletedImportDate()
{
$date = null;
$sOQL = "SELECT SynchroLog WHERE sync_source_id = :source_id AND status='completed'";
$oSet = new DBObjectSet(
DBObjectSearch::FromOQL($sOQL),
['end_date' => false] /* order by*/,
['source_id' => $this->GetKey()] /* aArgs */,
[],
0 /* limitCount */,
0 /* limitStart */
);
if ($oSet->Count() >= 1) {
$oLog = $oSet->Fetch();
$date = $oLog->Get('end_date');
}
return $date;
}
}
class SynchroAttribute extends cmdbAbstractObject
{
public static function Init()
{
$aParams =
[
'category' => 'core/cmdb,view_in_gui,grant_by_profile',
'key_type' => 'autoincrement',
'name_attcode' => 'attcode',
'state_attcode' => '',
'reconc_keys' => [],
'db_table' => 'priv_sync_att',
'db_key_field' => 'id',
'db_finalclass_field' => '',
'display_template' => '',
];
MetaModel::Init_Params($aParams);
MetaModel::Init_InheritAttributes();
MetaModel::Init_AddAttribute(new AttributeExternalKey('sync_source_id', [
'targetclass' => 'SynchroDataSource',
'jointype' => '',
'allowed_values' => null,
'sql' => 'sync_source_id',
'is_null_allowed' => false,
'on_target_delete' => DEL_SILENT,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeExternalField(
'sync_source_name',
['allowed_values' => null, 'extkey_attcode' => 'sync_source_id', 'target_attcode' => 'name']
));
MetaModel::Init_AddAttribute(new AttributeString('attcode', [
'allowed_values' => null,
'sql' => 'attcode',
'default_value' => null,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeBoolean('update', [
'allowed_values' => null,
'sql' => 'update',
'default_value' => true,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeBoolean('reconcile', [
'allowed_values' => null,
'sql' => 'reconcile',
'default_value' => false,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeEnum('update_policy', [
'allowed_values' => new ValueSetEnum('master_locked,master_unlocked,write_if_empty'),
'sql' => 'update_policy',
'default_value' => 'master_locked',
'is_null_allowed' => false,
'depends_on' => [],
]));
// Display lists
MetaModel::Init_SetZListItems('details', [
'sync_source_id',
'attcode',
'update',
'reconcile',
'update_policy',
]); // Attributes to be displayed for the complete details
MetaModel::Init_SetZListItems(
'list',
['sync_source_id', 'attcode', 'update', 'reconcile', 'update_policy']
); // Attributes to be displayed for a list
// Search criteria
// MetaModel::Init_SetZListItems('standard_search', array('name')); // Criteria of the std search form
// MetaModel::Init_SetZListItems('advanced_search', array('name')); // Criteria of the advanced search form
}
}
class SynchroAttExtKey extends SynchroAttribute
{
public static function Init()
{
$aParams =
[
'category' => 'core/cmdb,view_in_gui,grant_by_profile',
'key_type' => 'autoincrement',
'name_attcode' => 'attcode',
'state_attcode' => '',
'reconc_keys' => [],
'db_table' => 'priv_sync_att_extkey',
'db_key_field' => 'id',
'db_finalclass_field' => '',
'display_template' => '',
];
MetaModel::Init_Params($aParams);
MetaModel::Init_InheritAttributes();
MetaModel::Init_AddAttribute(new AttributeString('reconciliation_attcode', [
'allowed_values' => null,
'sql' => 'reconciliation_attcode',
'default_value' => null,
'is_null_allowed' => true,
'depends_on' => [],
]));
// Display lists
MetaModel::Init_SetZListItems('details', [
'sync_source_id',
'attcode',
'update',
'reconcile',
'update_policy',
'reconciliation_attcode',
]); // Attributes to be displayed for the complete details
MetaModel::Init_SetZListItems(
'list',
['sync_source_id', 'attcode', 'update', 'reconcile', 'update_policy']
); // Attributes to be displayed for a list
// Search criteria
// MetaModel::Init_SetZListItems('standard_search', array('name')); // Criteria of the std search form
// MetaModel::Init_SetZListItems('advanced_search', array('name')); // Criteria of the advanced search form
}
public function GetReconciliationFormElement($sTargetClass, $sFieldName)
{
$sHtml = "<div class=\"field_input_zone field_input_string ibo-input-wrapper ibo-input-select-wrapper\"'><select name=\"$sFieldName\" class=\"ibo-input ibo-input-select\">\n";
// Id
$sSelected = ('' == $this->Get('reconciliation_attcode')) ? ' selected' : '';
$sHtml .= "<option value=\"\" $sSelected>".Dict::S('Core:SynchroAttExtKey:ReconciliationById')."</option>\n";
// Friendly name
$sSelected = ('friendlyname' == $this->Get('reconciliation_attcode')) ? ' selected' : '';
$sHtml .= "<option value=\"friendlyname\" $sSelected>".MetaModel::GetLabel($sTargetClass, 'friendlyname')."</option>\n";
// Separator
$sHtml .= '<option value="" disabled>———————————</option>'; // Note: using the em-dash character which has no space between 2 characters
// Then add all remaining scalar attributes, sorted alphabetically
$aMoreOptions = [];
foreach (MetaModel::ListAttributeDefs($sTargetClass) as $sAttCode => $oAttDef) {
if ($oAttDef->IsScalar() && ($sAttCode != 'friendlyname')) {
$sSelected = ($sAttCode == $this->Get('reconciliation_attcode')) ? ' selected' : '';
$aMoreOptions[MetaModel::GetLabel(
$sTargetClass,
$sAttCode
)] = "<option value=\"$sAttCode\" $sSelected>".MetaModel::GetLabel($sTargetClass, $sAttCode)."</option>\n";
}
}
ksort($aMoreOptions);
foreach ($aMoreOptions as $sOption) {
$sHtml .= $sOption;
}
$sHtml .= "</select></div>\n";
return $sHtml;
}
}
class SynchroAttLinkSet extends SynchroAttribute
{
public static function Init()
{
$aParams =
[
'category' => 'core/cmdb,view_in_gui,grant_by_profile',
'key_type' => 'autoincrement',
'name_attcode' => 'attcode',
'state_attcode' => '',
'reconc_keys' => [],
'db_table' => 'priv_sync_att_linkset',
'db_key_field' => 'id',
'db_finalclass_field' => '',
'display_template' => '',
];
MetaModel::Init_Params($aParams);
MetaModel::Init_InheritAttributes();
MetaModel::Init_AddAttribute(new AttributeString('row_separator', [
'allowed_values' => null,
'sql' => 'row_separator',
'default_value' => '|',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeString('attribute_separator', [
'allowed_values' => null,
'sql' => 'attribute_separator',
'default_value' => ';',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeString('value_separator', [
'allowed_values' => null,
'sql' => 'value_separator',
'default_value' => ':',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeString('attribute_qualifier', [
'allowed_values' => null,
'sql' => 'attribute_qualifier',
'default_value' => '\'',
'is_null_allowed' => true,
'depends_on' => [],
]));
// Display lists
MetaModel::Init_SetZListItems('details', [
'sync_source_id',
'attcode',
'update',
'reconcile',
'update_policy',
'row_separator',
'attribute_separator',
'value_separator',
'attribute_qualifier',
]); // Attributes to be displayed for the complete details
MetaModel::Init_SetZListItems(
'list',
['sync_source_id', 'attcode', 'update', 'reconcile', 'update_policy']
); // Attributes to be displayed for a list
// Search criteria
// MetaModel::Init_SetZListItems('standard_search', array('name')); // Criteria of the std search form
// MetaModel::Init_SetZListItems('advanced_search', array('name')); // Criteria of the advanced search form
}
}
//class SynchroLog extends Event
class SynchroLog extends DBObject
{
public static function Init()
{
$aParams =
[
'category' => 'core/cmdb,view_in_gui,grant_by_profile',
'key_type' => 'autoincrement',
'name_attcode' => '',
'state_attcode' => '',
'reconc_keys' => [],
'db_table' => 'priv_sync_log',
'db_key_field' => 'id',
'db_finalclass_field' => '',
'display_template' => '',
];
MetaModel::Init_Params($aParams);
MetaModel::Init_InheritAttributes();
// MetaModel::Init_AddAttribute(new AttributeString("userinfo", array("allowed_values"=>null, "sql"=>"userinfo", "default_value"=>null, "is_null_allowed"=>true, "depends_on"=>array())));
MetaModel::Init_AddAttribute(new AttributeExternalKey('sync_source_id', [
'targetclass' => 'SynchroDataSource',
'jointype' => '',
'allowed_values' => null,
'sql' => 'sync_source_id',
'is_null_allowed' => false,
'on_target_delete' => DEL_SILENT,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeDateTime('start_date', [
'allowed_values' => null,
'sql' => 'start_date',
'default_value' => '',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeDateTime('end_date', [
'allowed_values' => null,
'sql' => 'end_date',
'default_value' => '',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeEnum('status', [
'allowed_values' => new ValueSetEnum('running,completed,error'),
'sql' => 'status',
'default_value' => 'running',
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('status_curr_job', [
'allowed_values' => null,
'sql' => 'status_curr_job',
'default_value' => 0,
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('status_curr_pos', [
'allowed_values' => null,
'sql' => 'status_curr_pos',
'default_value' => 0,
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_replica_seen', [
'allowed_values' => null,
'sql' => 'stats_nb_replica_seen',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_replica_total', [
'allowed_values' => null,
'sql' => 'stats_nb_replica_total',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_deleted', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_deleted',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_deleted_errors', [
'allowed_values' => null,
'sql' => 'stats_deleted_errors',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_obsoleted', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_obsoleted',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_obsoleted_errors', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_obsoleted_errors',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_created', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_created',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_created_errors', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_created_errors',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_created_warnings', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_created_warnings',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_updated', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_updated',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_updated_errors', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_updated_errors',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_updated_warnings', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_updated_warnings',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_unchanged_warnings', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_unchanged_warnings',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
// MetaModel::Init_AddAttribute(new AttributeInteger("stats_nb_replica_reconciled", array("allowed_values"=>null, "sql"=>"stats_nb_replica_reconciled", "default_value"=>0, "is_null_allowed"=>false, "depends_on"=>array())));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_replica_reconciled_errors', [
'allowed_values' => null,
'sql' => 'stats_nb_replica_reconciled_errors',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_replica_disappeared_no_action', [
'allowed_values' => null,
'sql' => 'stats_nb_replica_disappeared_no_action',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_new_updated', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_new_updated',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_new_updated_warnings', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_new_updated_warnings',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_new_unchanged', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_new_unchanged',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeInteger('stats_nb_obj_new_unchanged_warnings', [
'allowed_values' => null,
'sql' => 'stats_nb_obj_new_unchanged_warnings',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeText('last_error', [
'allowed_values' => null,
'sql' => 'last_error',
'default_value' => '',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeLongText(
'traces',
['allowed_values' => null, 'sql' => 'traces', 'default_value' => '', 'is_null_allowed' => true, 'depends_on' => []]
));
MetaModel::Init_AddAttribute(new AttributeInteger('memory_usage_peak', [
'allowed_values' => null,
'sql' => 'memory_usage_peak',
'default_value' => 0,
'is_null_allowed' => false,
'depends_on' => [],
]));
// Display lists
MetaModel::Init_SetZListItems('details', [
'sync_source_id',
'start_date',
'end_date',
'status',
'stats_nb_replica_total',
'stats_nb_replica_seen',
'stats_nb_obj_created', /*'stats_nb_replica_reconciled',*/ 'stats_nb_obj_updated',
'stats_nb_obj_obsoleted',
'stats_nb_obj_deleted',
'stats_nb_obj_created_errors',
'stats_nb_replica_reconciled_errors',
'stats_nb_replica_disappeared_no_action',
'stats_nb_obj_updated_errors',
'stats_nb_obj_obsoleted_errors',
'stats_nb_obj_deleted_errors',
'stats_nb_obj_new_unchanged',
'stats_nb_obj_new_updated',
'traces',
]); // Attributes to be displayed for the complete details
MetaModel::Init_SetZListItems(
'list',
['sync_source_id', 'start_date', 'end_date', 'status', 'stats_nb_replica_seen']
); // Attributes to be displayed for a list
// Search criteria
// MetaModel::Init_SetZListItems('standard_search', array('name')); // Criteria of the std search form
// MetaModel::Init_SetZListItems('advanced_search', array('name')); // Criteria of the advanced search form
}
/**
* Helper
*/
public function GetErrorCount()
{
return $this->Get('stats_nb_obj_deleted_errors')
+ $this->Get('stats_nb_obj_obsoleted_errors')
+ $this->Get('stats_nb_obj_created_errors')
+ $this->Get('stats_nb_obj_updated_errors')
+ $this->Get('stats_nb_replica_reconciled_errors');
}
/**
* Increments a statistics counter
*
* @param string $sCode
*/
public function Inc($sCode)
{
$this->Set($sCode, 1 + $this->Get($sCode));
}
/**
* Implement traces management
*/
protected $m_aTraces = [];
public function AddTrace($sMsg, $oReplica = null)
{
if (MetaModel::GetConfig()->Get('synchro_trace') == 'none') {
return;
}
if ($oReplica) {
$sDestClass = $oReplica->Get('dest_class');
if (!empty($sDestClass)) {
$sPrefix = $oReplica->GetKey().','.$sDestClass.'::'.$oReplica->Get('dest_id').',';
} else {
$sPrefix = $oReplica->GetKey().',,';
}
} else {
$sPrefix = ',,';
}
$this->m_aTraces[] = $sPrefix.$sMsg;
}
public function GetTraces()
{
return $this->m_aTraces;
}
protected function TraceToText()
{
if (MetaModel::GetConfig()->Get('synchro_trace') != 'save') {
// none, or display only
return;
}
$sPrevTrace = $this->Get('traces');
$oAttDef = MetaModel::GetAttributeDef(get_class($this), 'traces');
$iMaxSize = $oAttDef->GetMaxSize();
if (strlen($sPrevTrace) > 0) {
$sTrace = $sPrevTrace."\n".implode("\n", $this->m_aTraces);
} else {
$sTrace = implode("\n", $this->m_aTraces);
}
if (mb_strlen($sTrace) >= $iMaxSize) {
$sTrace = mb_substr($sTrace, 0, $iMaxSize - 40)."...\nTruncated (size: ".mb_strlen($sTrace).')';
}
$this->Set('traces', $sTrace);
//DBUpdate may be called many times... the operation should not be repeated
$this->m_aTraces = [];
}
protected function OnInsert()
{
$this->TraceToText();
parent::OnInsert();
}
protected function OnUpdate()
{
$this->TraceToText();
$sMemPeak = max($this->Get('memory_usage_peak'), ExecutionKPI::memory_get_peak_usage());
// memory peak overflow protection
if ($sMemPeak > 2147483647) {
$sMemPeak = 2147483647;
}
$this->Set('memory_usage_peak', $sMemPeak);
parent::OnUpdate();
}
}
class SynchroReplica extends DBObject implements iDisplay
{
public static $aSearches = []; // Cache of OQL queries used for reconciliation (per data source)
protected $aWarnings;
public static function Init()
{
$aParams =
[
'category' => 'core/cmdb,view_in_gui,grant_by_profile',
'key_type' => 'autoincrement',
'name_attcode' => '',
'state_attcode' => '',
'reconc_keys' => [],
'db_table' => 'priv_sync_replica',
'db_key_field' => 'id',
'db_finalclass_field' => '',
'display_template' => '',
'indexes' => [['dest_class', 'dest_id'],],
];
MetaModel::Init_Params($aParams);
MetaModel::Init_InheritAttributes();
MetaModel::Init_AddAttribute(new AttributeExternalKey('sync_source_id', [
'targetclass' => 'SynchroDataSource',
'jointype' => '',
'allowed_values' => null,
'sql' => 'sync_source_id',
'is_null_allowed' => false,
'on_target_delete' => DEL_NONE,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeExternalField(
'base_class',
['allowed_values' => null, 'extkey_attcode' => 'sync_source_id', 'target_attcode' => 'scope_class']
));
MetaModel::Init_AddAttribute(new AttributeObjectKey('dest_id', [
'allowed_values' => null,
'class_attcode' => 'dest_class',
'sql' => 'dest_id',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeClass('dest_class', [
'class_category' => '',
'more_values' => '',
'sql' => 'dest_class',
'default_value' => '',
'is_null_allowed' => true,
'depends_on' => [],
"class_exclusion_list" => null,
]));
MetaModel::Init_AddAttribute(new AttributeDateTime('status_last_seen', [
'allowed_values' => null,
'sql' => 'status_last_seen',
'default_value' => 'NOW()',
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeEnum('status', [
'allowed_values' => new ValueSetEnum('new,synchronized,modified,orphan,obsolete'),
'sql' => 'status',
'default_value' => 'new',
'is_null_allowed' => false,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeBoolean('status_dest_creator', [
'allowed_values' => null,
'sql' => 'status_dest_creator',
'default_value' => 0,
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeString('status_last_error', [
'allowed_values' => null,
'sql' => 'status_last_error',
'default_value' => '',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeString('status_last_warning', [
'allowed_values' => null,
'sql' => 'status_last_warning',
'default_value' => '',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeDateTime('info_creation_date', [
'allowed_values' => null,
'sql' => 'info_creation_date',
'default_value' => '',
'is_null_allowed' => true,
'depends_on' => [],
]));
MetaModel::Init_AddAttribute(new AttributeDateTime('info_last_modified', [
'allowed_values' => null,
'sql' => 'info_last_modified',
'default_value' => '',
'is_null_allowed' => true,
'depends_on' => [],
]));
// Display lists
MetaModel::Init_SetZListItems(
'details',
[
''.
'col:0' => [
'fieldset:SynchroDataSource:Definition' => ['sync_source_id', 'dest_id', 'dest_class'],
'fieldset:SynchroDataSource:Status' => [
'status',
'status_last_seen',
'status_dest_creator',
'status_last_error',
'status_last_warning',
],
'fieldset:SynchroDataSource:Information' => ['info_creation_date', 'info_last_modified'],
],
]
);
MetaModel::Init_SetZListItems('list', [
'sync_source_id',
'dest_id',
'dest_class',
'status_last_seen',
'status',
'status_dest_creator',
'status_last_error',
'status_last_warning',
]); // Attributes to be displayed for a list
// Search criteria
MetaModel::Init_SetZListItems('standard_search', [
'sync_source_id',
'status_last_seen',
'status',
'status_dest_creator',
'dest_class',
'dest_id',
'status_last_error',
'status_last_warning',
]); // Criteria of the std search form
// MetaModel::Init_SetZListItems('advanced_search', array('name')); // Criteria of the advanced search form
}
public function __construct($aRow = null, $sClassAlias = '', $aAttToLoad = null, $aExtendedDataSpec = null)
{
parent::__construct($aRow, $sClassAlias, $aAttToLoad, $aExtendedDataSpec);
$this->aWarnings = [];
}
protected function AddWarning($sWarningMessage)
{
$this->aWarnings[] = $sWarningMessage;
}
protected function ResetWarnings()
{
$this->aWarnings = [];
}
protected function HasWarnings()
{
return (count($this->aWarnings) > 0);
}
protected function RecordWarnings()
{
$MAX_WARNING_LENGTH = 255;
switch (count($this->aWarnings)) {
case 0:
$sWarningMessage = '';
break;
case 1:
$sWarningMessage = $this->aWarnings[0];
break;
default:
$sWarningMessage = count($this->aWarnings).' warnings: '.implode(' ', $this->aWarnings);
break;
}
if (mb_strlen($sWarningMessage) > $MAX_WARNING_LENGTH) {
$sWarningMessage = mb_substr($sWarningMessage, 0, $MAX_WARNING_LENGTH - 3).'...';
}
$this->Set('status_last_warning', $sWarningMessage);
}
public function DBInsert()
{
throw new CoreException('A synchronization replica must be created only by the mean of triggers');
}
// Overload the deletion -> the replica has been created by the mean of a trigger,
// it will be deleted by SynchroDataSource::AfterDelete
protected function DBDeleteSingleObject()
{
if (!MetaModel::DBIsReadOnly()) {
$oDataSource = MetaModel::GetObject('SynchroDataSource', $this->Get('sync_source_id'), false);
if ($oDataSource) {
$sTable = $oDataSource->GetDataTable();
$sSQL = "DELETE FROM `$sTable` WHERE id = '{$this->GetKey()}'";
CMDBSource::Query($sSQL);
}
// else the whole datasource has probably been already deleted
}
parent::DBDeleteSingleObject();
}
public function SetLastError($sMessage, $oException = null)
{
if ($oException) {
$sText = $sMessage.$oException->getMessage();
} else {
$sText = $sMessage;
}
if (mb_strlen($sText) > 255) {
$sText = mb_substr($sText, 0, 200).'...('.mb_strlen($sText).' chars)...';
}
$this->Set('status_last_error', $sText);
}
public function Synchro($oDataSource, $aReconciliationKeys, $aAttributes, $oChange, &$oStatLog)
{
$oStatLog->AddTrace(">>> Beginning of SynchroReplica::Synchro, replica status is '".$this->Get('status')."'.", $this);
$this->ResetWarnings();
switch ($this->Get('status')) {
case 'new':
$this->Set('status_dest_creator', false);
// If needed, construct the query used for the reconciliation
if (!isset(self::$aSearches[$oDataSource->GetKey()])) {
$aCriterias = [];
foreach ($aReconciliationKeys as $sFilterCode => $oSyncAtt) {
$aCriterias[] = ($sFilterCode == 'primary_key' ? 'id' : $sFilterCode).' = :'.$sFilterCode;
}
$sOQL = 'SELECT '.$oDataSource->GetTargetClass().' WHERE '.implode(' AND ', $aCriterias);
self::$aSearches[$oDataSource->GetKey()] = DBObjectSearch::FromOQL($sOQL);
}
// Get the criterias for the search
$aFilterValues = [];
foreach ($aReconciliationKeys as $sFilterCode => $oSyncAtt) {
$value = $this->GetValueFromExtData($sFilterCode, $oSyncAtt, $oStatLog);
if (!is_null($value)) {
$aFilterValues[$sFilterCode] = $value;
} else {
// TO DO: can we retry this ??
// Reconciliation could not be performed - log and EXIT
$oStatLog->AddTrace("Could not reconcile on null value for attribute '$sFilterCode'", $this);
$this->SetLastError("Could not reconcile on null value for attribute '$sFilterCode'");
$oStatLog->Inc('stats_nb_replica_reconciled_errors');
$oStatLog->AddTrace(
"<<< End of SyncroReplica::Synchro (error could not reconcile on null value for attribute '$sFilterCode').",
$this
);
return;
}
}
$oDestSet = new DBObjectSet(self::$aSearches[$oDataSource->GetKey()], [], $aFilterValues);
$iCount = $oDestSet->Count();
$sDebugOQL = $oDestSet->GetFilter()->ToOQL(true);
$oStatLog->AddTrace("Reconciliation query: '$sDebugOQL' returned $iCount object(s).", $this);
$aConditions = [];
foreach ($aFilterValues as $sCode => $sValue) {
$aConditions[] = $sCode.'='.$sValue;
}
$sConditionDesc = implode(' AND ', $aConditions);
// How many objects match the reconciliation criterias
switch ($iCount) {
case 0:
$oStatLog->AddTrace("Nothing found on: $sConditionDesc", $this);
if ($oDataSource->Get('action_on_zero') == 'create') {
$oStatLog->AddTrace('Calling CreateObjectFromReplica', $this);
$bCreated = $this->CreateObjectFromReplica($oDataSource->GetTargetClass(), $aAttributes, $oChange, $oStatLog);
if ($bCreated) {
if ($this->HasWarnings()) {
$oStatLog->Inc('stats_nb_obj_created_warnings');
}
} else {
// Creation error has precedence over any warning
$this->ResetWarnings();
}
} else { // assumed to be 'error'
$oStatLog->AddTrace('Failed to reconcile (no match)', $this);
// Recoverable error
$this->SetLastError('Could not find a match for reconciliation');
$oStatLog->Inc('stats_nb_replica_reconciled_errors');
}
break;
case 1:
$oStatLog->AddTrace("Found 1 object on: $sConditionDesc", $this);
if ($oDataSource->Get('action_on_one') == 'update') {
$oDestObj = $oDestSet->Fetch();
$oStatLog->AddTrace(
'Calling UpdateObjectFromReplica('.(get_class($oDestObj).'::'.$oDestObj->GetKey()).')',
$this
);
$bModified = $this->UpdateObjectFromReplica(
$oDestObj,
$aAttributes,
$oChange,
$oStatLog,
'stats_nb_obj_new',
'stats_nb_replica_reconciled_errors'
);
$this->Set('dest_id', $oDestObj->GetKey());
$this->Set('dest_class', get_class($oDestObj));
if ($this->HasWarnings()) {
if ($bModified) {
$oStatLog->Inc('stats_nb_obj_new_updated_warnings');
} else {
$oStatLog->Inc('stats_nb_obj_new_unchanged_warnings');
}
}
} else {
// assumed to be 'error'
$oStatLog->AddTrace('Failed to reconcile (1 match)', $this);
// Recoverable error
$this->SetLastError('Found a match while expecting several');
$oStatLog->Inc('stats_nb_replica_reconciled_errors');
}
break;
default:
$oStatLog->AddTrace("Found $iCount objects on: $sConditionDesc", $this);
if ($oDataSource->Get('action_on_multiple') == 'error') {
$oStatLog->AddTrace('Failed to reconcile (N>1 matches)', $this);
// Recoverable error
$this->SetLastError($iCount.' destination objects match the reconciliation criterias: '.$sConditionDesc);
$oStatLog->Inc('stats_nb_replica_reconciled_errors');
} elseif ($oDataSource->Get('action_on_multiple') == 'create') {
$bCreated = $this->CreateObjectFromReplica($oDataSource->GetTargetClass(), $aAttributes, $oChange, $oStatLog);
if ($bCreated) {
if ($this->HasWarnings()) {
$oStatLog->Inc('stats_nb_obj_created_warnings');
}
} else {
// Creation error has precedence over any warning
$this->ResetWarnings();
}
} else {
// assumed to be 'take_first'
$oDestObj = $oDestSet->Fetch();
$bModified = $this->UpdateObjectFromReplica(
$oDestObj,
$aAttributes,
$oChange,
$oStatLog,
'stats_nb_obj_new',
'stats_nb_replica_reconciled_errors'
);
$this->Set('dest_id', $oDestObj->GetKey());
$this->Set('dest_class', get_class($oDestObj));
if ($this->HasWarnings()) {
if ($bModified) {
$oStatLog->Inc('stats_nb_obj_new_updated_warnings');
} else {
$oStatLog->Inc('stats_nb_obj_new_unchanged_warnings');
}
}
}
}
$this->RecordWarnings();
break;
case 'synchronized': // try to recover synchronized replicas with warnings
case 'modified':
$oDestObj = MetaModel::GetObject($oDataSource->GetTargetClass(), $this->Get('dest_id'));
if ($oDestObj == null) {
$this->Set('status', 'orphan'); // The destination object has been deleted !
$this->SetLastError('Destination object deleted unexpectedly');
$oStatLog->Inc('stats_nb_obj_updated_errors');
} else {
$bModified = $this->UpdateObjectFromReplica(
$oDestObj,
$aAttributes,
$oChange,
$oStatLog,
'stats_nb_obj',
'stats_nb_obj_updated_errors'
);
if ($this->HasWarnings()) {
if ($bModified) {
$oStatLog->Inc('stats_nb_obj_updated_warnings');
} else {
$oStatLog->Inc('stats_nb_obj_unchanged_warnings');
}
}
}
$this->RecordWarnings();
break;
default: // Do nothing in all other cases
}
$oStatLog->AddTrace('<<< End of SynchroReplica::Synchro.', $this);
}
/**
* Updates the destination object with the Extended data found in the synchro_data_XXXX table
*
* @param \CMDBObject $oDestObj
* @param string[] $aAttributes
* @param \CMDBChange $oChange
* @param \SynchroLog $oStatLog
* @param string $sStatsCode
* @param string $sStatsCodeError
*
* @return bool
*/
protected function UpdateObjectFromReplica($oDestObj, $aAttributes, $oChange, &$oStatLog, $sStatsCode, $sStatsCodeError)
{
$aValueTrace = [];
$bModified = false;
try {
foreach ($aAttributes as $sAttCode => $oSyncAtt) {
$value = $this->GetValueFromExtData($sAttCode, $oSyncAtt, $oStatLog);
if (!is_null($value)) {
if ($oSyncAtt->Get('update_policy') == 'write_if_empty') {
$oAttDef = MetaModel::GetAttributeDef(get_class($oDestObj), $sAttCode);
if ($oAttDef->IsNull($oDestObj->Get($sAttCode))) {
// The value is still "empty" in the target object, we are allowed to write the new value
$oDestObj->Set($sAttCode, $value);
$aValueTrace[] = "$sAttCode: $value";
}
} else {
$oDestObj->Set($sAttCode, $value);
$aValueTrace[] = "$sAttCode: $value";
}
}
}
// Really modified ?
if ($oDestObj->IsModified()) {
if (method_exists(get_class($oDestObj), "SetCurrentChange")) {
$oDestObj::SetCurrentChange($oChange);
}
$oDestObj->DBUpdate();
$bModified = true;
$oStatLog->AddTrace('Updated object - Values: {'.implode(', ', $aValueTrace).'}', $this);
if (($sStatsCode != '') && (MetaModel::IsValidAttCode(get_class($oStatLog), $sStatsCode.'_updated'))) {
$oStatLog->Inc($sStatsCode.'_updated');
}
$this->Set('info_last_modified', date(AttributeDateTime::GetSQLFormat()));
} else {
$oStatLog->AddTrace('Unchanged object', $this);
if (($sStatsCode != '') && (MetaModel::IsValidAttCode(get_class($oStatLog), $sStatsCode.'_unchanged'))) {
$oStatLog->Inc($sStatsCode.'_unchanged');
}
}
$this->Set('status_last_error', '');
$this->Set('status', 'synchronized');
} catch (Exception $e) {
$oStatLog->AddTrace("Failed to update destination object: {$e->getMessage()}", $this);
$this->SetLastError('Unable to update destination object: ', $e);
$oStatLog->Inc($sStatsCodeError);
}
return $bModified;
}
/**
* Creates the destination object populating it with the Extended data found in the synchro_data_XXXX table
*
* @param string $sClass
* @param string[] $aAttributes
* @param $oChange
* @param $oStatLog
*
* @return bool true if the object was created
* @throws \CoreException
*/
protected function CreateObjectFromReplica($sClass, $aAttributes, $oChange, &$oStatLog)
{
$bCreated = false;
$oDestObj = MetaModel::NewObject($sClass);
try {
$aValueTrace = [];
foreach ($aAttributes as $sAttCode => $oSyncAtt) {
$value = $this->GetValueFromExtData($sAttCode, $oSyncAtt, $oStatLog);
if (!is_null($value)) {
$oDestObj->Set($sAttCode, $value);
$aValueTrace[] = "$sAttCode: $value";
}
}
if (method_exists(get_class($oDestObj), "SetCurrentChange")) {
$oDestObj::SetCurrentChange($oChange);
}
$iNew = $oDestObj->DBInsert();
$this->Set('dest_id', $oDestObj->GetKey());
$this->Set('dest_class', get_class($oDestObj));
$this->Set('status_dest_creator', true);
$this->Set('status_last_error', '');
$this->Set('status', 'synchronized');
$this->Set('info_creation_date', date(AttributeDateTime::GetSQLFormat()));
$bCreated = true;
$oStatLog->AddTrace('Created ('.implode(', ', $aValueTrace).')', $this);
$oStatLog->Inc('stats_nb_obj_created');
} catch (Exception $e) {
$oStatLog->AddTrace("Failed to create $sClass ({$e->getMessage()})", $this);
$this->SetLastError('Unable to create destination object: ', $e);
$oStatLog->Inc('stats_nb_obj_created_errors');
}
return $bCreated;
}
/**
* Update the destination object with given values
*
* @param array $aValues
* @param CMDBChange $oChange
* @param SynchroLog $oStatLog
*/
public function UpdateDestObject($aValues, $oChange, &$oStatLog)
{
try {
if ($this->Get('dest_class') === '') {
$this->SetLastError('No destination object to update');
$oStatLog->Inc('stats_nb_obj_obsoleted_errors');
} else {
/** @var \CMDBObject $oDestObj */
$oDestObj = MetaModel::GetObject($this->Get('dest_class'), $this->Get('dest_id'));
foreach ($aValues as $sAttCode => $value) {
if (!MetaModel::IsValidAttCode(get_class($oDestObj), $sAttCode)) {
throw new Exception("Unknown attribute code '$sAttCode'");
}
$oDestObj->Set($sAttCode, $value);
}
$this->Set('info_last_modified', date(AttributeDateTime::GetSQLFormat()));
$oDestObj::SetCurrentChange($oChange);
$oDestObj->DBUpdate();
$oStatLog->AddTrace('Replica marked as obsolete', $this);
$oStatLog->Inc('stats_nb_obj_obsoleted');
}
} catch (Exception $e) {
$this->SetLastError('Unable to update the destination object: ', $e);
$oStatLog->Inc('stats_nb_obj_obsoleted_errors');
}
}
/**
* Delete the destination object
*
* @param CMDBChange $oChange
* @param SynchroLog $oStatLog
*
* @throws \ArchivedObjectException
* @throws \CoreCannotSaveObjectException
* @throws \CoreException
* @throws \CoreUnexpectedValue
* @throws \DeleteException
* @throws \MySQLException
* @throws \MySQLHasGoneAwayException
* @throws \OQLException
*/
public function DeleteDestObject($oChange, &$oStatLog)
{
if ($this->Get('status_dest_creator')) {
try {
$oDestObj = MetaModel::GetObject($this->Get('dest_class'), $this->Get('dest_id'));
$oCheckDeletionPlan = new DeletionPlan();
if ($oDestObj->CheckToDelete($oCheckDeletionPlan)) {
$oDestObj::SetCurrentChange($oChange);
$oDestObj->DBDelete();
$this->DBDelete();
$oStatLog->Inc('stats_nb_obj_deleted');
} else {
$sIssues = implode("\n", $oCheckDeletionPlan->GetIssues());
throw(new Exception($sIssues));
}
} catch (Exception $e) {
$this->SetLastError('Unable to delete the destination object: ', $e);
$this->Set('status', 'obsolete');
$this->DBUpdate();
$oStatLog->Inc('stats_nb_obj_deleted_errors');
}
} else {
$this->DBDelete();
$oStatLog->Inc('stats_nb_replica_disappeared_no_action');
}
}
/**
* Get the value from the 'Extended Data' located in the synchro_data_xxx table for this replica
*
* @param string $sExtAttCode could be a standard attcode, or 'primary_key'
* @param $oSyncAtt
* @param $oStatLog
*
* @return mixed , or null (leave unchanged), or '' (reset)
*/
protected function GetValueFromExtData($sExtAttCode, $oSyncAtt, &$oStatLog)
{
// $aData should contain attributes defined either for reconciliation or create/update
$aData = $this->GetExtendedData();
if ($sExtAttCode == 'primary_key') {
return $aData['primary_key'];
}
// $sExtAttCode is a valid attribute code
//
$sClass = $this->Get('base_class');
$oAttDef = MetaModel::GetAttributeDef($sClass, $sExtAttCode);
if (!is_null($oSyncAtt) && ($oSyncAtt instanceof SynchroAttExtKey)) {
$rawValue = $aData[$sExtAttCode];
if (is_null($rawValue)) {
// Null means "ignore" this attribute
return null;
}
$sReconcAttCode = $oSyncAtt->Get('reconciliation_attcode');
if (!empty($sReconcAttCode)) {
$sRemoteClass = $oAttDef->GetTargetClass();
$oObj = MetaModel::GetObjectByColumn($sRemoteClass, $sReconcAttCode, $rawValue, false);
if ($oObj) {
$retValue = $oObj->GetKey();
} else {
if ($rawValue != '') {
// Note: differs from null (in which case the value would be left unchanged)
$oStatLog->AddTrace(
"Could not find [unique] object for '$sExtAttCode': searched on $sReconcAttCode = '$rawValue'",
$this
);
$this->AddWarning("Could not find [unique] object for '$sExtAttCode': searched on $sReconcAttCode = '$rawValue'");
}
$retValue = 0;
}
} else {
$retValue = $rawValue;
}
} elseif (!is_null($oSyncAtt) && ($oSyncAtt instanceof SynchroAttLinkSet)) {
$rawValue = $aData[$sExtAttCode];
if (is_null($rawValue)) {
// Null means "ignore" this attribute
return null;
}
// MakeValueFromString() throws an exception in case of failure
$bLocalizedValue = false;
$retValue = $oAttDef->MakeValueFromString(
$rawValue,
$bLocalizedValue,
$oSyncAtt->Get('row_separator'),
$oSyncAtt->Get('attribute_separator'),
$oSyncAtt->Get('value_separator'),
$oSyncAtt->Get('attribute_qualifier')
);
} else {
$aColumns = $oAttDef->GetImportColumns();
foreach ($aColumns as $sColumn => $sFormat) {
// In any case, a null column means "ignore this attribute"
//
if (is_null($aData[$sColumn])) {
return null;
}
}
// No null column has been found
$retValue = $oAttDef->FromImportToValue($aData, $sExtAttCode);
if (is_null($retValue)) {
// This is a reset
$retValue = '';
}
}
return $retValue;
}
/**
* Maps the given context parameter name to the appropriate filter/search code for this class
*
* @param string $sContextParam Name of the context parameter, i.e. 'org_id'
*
* @return string Filter code, i.e. 'customer_id'
*/
public static function MapContextParam($sContextParam)
{
if ($sContextParam == 'menu') {
return null;
} else {
return $sContextParam;
}
}
/**
* This function returns a 'hilight' CSS class, used to hilight a given row in a table
* There are currently (i.e defined in the CSS) 4 possible values HILIGHT_CLASS_CRITICAL,
* HILIGHT_CLASS_WARNING, HILIGHT_CLASS_OK, HILIGHT_CLASS_NONE
* To Be overridden by derived classes
*
* @param void
*
* @return String The desired higlight class for the object/row
*/
public function GetHilightClass()
{
// Possible return values are:
// HILIGHT_CLASS_CRITICAL, HILIGHT_CLASS_WARNING, HILIGHT_CLASS_OK, HILIGHT_CLASS_NONE
return HILIGHT_CLASS_NONE; // Not hilighted by default
}
public static function GetUIPage()
{
return '../synchro/replica.php';
}
public function DisplayDetails(WebPage $oPage, $bEditMode = false)
{
// Object's details
//$this->DisplayBareHeader($oPage, $bEditMode);
$oPage->AddTabContainer(OBJECT_PROPERTIES_TAB);
$oPage->SetCurrentTabContainer(OBJECT_PROPERTIES_TAB);
$oPage->SetCurrentTab('UI:PropertiesTab');
$this->DisplayBareProperties($oPage, $bEditMode);
}
public function DisplayBareProperties(WebPage $oPage, $bEditMode = false, $sPrefix = '', $aExtraParams = [])
{
if ($bEditMode) {
return;
} // Not editable
$oPage->add('<div class="ibo-multi-column"><div class="ibo-column">');
$aDetails = [];
$sClass = get_class($this);
$oPage->add('<fieldset class="ibo-fieldset">');
$oPage->add('<legend class="ibo-fieldset-legend">'.Dict::S('Core:SynchroReplica:PrivateDetails').'</legend>');
$aZList = MetaModel::FlattenZlist(MetaModel::GetZListItems($sClass, 'details'));
foreach ($aZList as $sAttCode) {
$sDisplayValue = $this->GetAsHTML($sAttCode);
$aDetails[] = [
'label' => '<span title="'.MetaModel::GetDescription($sClass, $sAttCode).'">'.MetaModel::GetLabel(
$sClass,
$sAttCode
).'</span>',
'value' => $sDisplayValue,
];
}
$oPage->Details($aDetails);
$oPage->add('</fieldset>');
$sDestClass = $this->Get('dest_class');
$bCanDisplayDestObjSections = true;
if (strlen($sDestClass) > 0) {
$oDestObj = MetaModel::GetObject($sDestClass, $this->Get('dest_id'), false);
if (is_object($oDestObj)) {
$bCanDisplayDestObjSections = UserRights::IsActionAllowed($sDestClass, UR_ACTION_READ, DBObjectSet::FromObject($oDestObj));
if ($bCanDisplayDestObjSections) {
$oPage->add('<fieldset class="ibo-fieldset">');
$oPage->add('<legend class="ibo-fieldset-legend">'.Dict::Format('Core:SynchroReplica:TargetObject', $oDestObj->GetHyperlink()).'</legend>');
$oDestObj->DisplayBareProperties($oPage, false, $sPrefix, $aExtraParams);
$oPage->add('<fieldset>');
}
} else {
$bCanDisplayDestObjSections = UserRights::IsActionAllowed($sDestClass, UR_ACTION_READ, null);
}
}
if ($bCanDisplayDestObjSections) {
$oPage->add('</div><div class="ibo-column">');
$oPage->add('<fieldset class="ibo-fieldset">');
$oPage->add('<legend class="ibo-fieldset-legend">'.Dict::S('Core:SynchroReplica:PublicData').'</legend>');
$oSource = MetaModel::GetObject('SynchroDataSource', $this->Get('sync_source_id'));
$sSQLTable = $oSource->GetDataTable();
$aData = $this->LoadExtendedDataFromTable($sSQLTable);
$aHeaders = [
'attcode' => ['label' => Dict::S('UI:Form:Property'), 'description' => ''],
'data' => ['label' => Dict::S('UI:Form:Value'), 'description' => ''],
];
$aRows = [];
foreach ($aData as $sKey => $value) {
if (strpos(CMDBSource::GetFieldType($sSQLTable, $sKey), 'blob') !== false) {
$aRows[] = ['attcode' => $sKey, 'data' => sprintf('<i>%s (%s)</i>', Dict::S('Core:AttributeBlob'), utils::BytesToFriendlyFormat(utils::StrLen($value)))];
} else {
$aRows[] = ['attcode' => $sKey, 'data' => utils::EscapeHtml($value)];
}
}
$oPage->Table($aHeaders, $aRows);
$oPage->add('</fieldset>');
$oPage->add('</div></div>');
}
}
public function LoadExtendedDataFromTable($sSQLTable)
{
$sSQL = "SELECT * FROM $sSQLTable WHERE id=".$this->GetKey();
$rQuery = CMDBSource::Query($sSQL);
return CMDBSource::FetchArray($rQuery);
}
}
/**
* Handles the execution phase of datasynchro (create, update, delete iTop objects from replicas)
*
* Usage:
*
* Execute the synchronization
* ```php
* $oSynchroExec = new SynchroExecution($oDataSource[, $iLastFullLoad]);
* $oSynchroExec->Process($iMaxChunkSize);
* ```
*/
class SynchroExecution
{
/** @var \SynchroDataSource */
protected $m_oDataSource = null;
/** @var \DateTime */
protected $m_oImportPhaseStartDate = null;
/**
* @var \DateTime The reference that will be used to query replicas.<br>
* Value is either :
* <ul>
* <li>specified by the caller (if it is doing both import and exec phases)
* <li>computed using current date minus the 'full load interval' datasource field
* <li>a dumb date if full load interval is 0 and doing only exec phase
* </ul>
*/
protected $m_oLastFullLoadStartDate = null;
/** @var bool true if the caller script gave the datetime before import phase was launched */
protected $m_bIsImportPhaseDateKnown;
/** @var \CMDBChange */
protected $m_oChange = null;
/** @var SynchroLog */
protected $m_oStatLog = null;
// Context computed one for optimization and report inconsistencies ASAP
protected $m_aExtDataSpec = [];
protected $m_aReconciliationKeys = [];
protected $m_aAttributes = [];
protected $m_iCountAllReplicas = 0;
protected $m_oCtx;
protected $m_oCtx1;
/**
* @param SynchroDataSource $oDataSource Synchronization task
* @param DateTime $oImportPhaseStartDate Start of the import when doing both import and exec phases in the same script. (This is used
* by `synchro_import.php --synchronize=1`) null when exec phase is used alone and the import start date is unknown.
*
* @throws \CoreException
*/
public function __construct($oDataSource, $oImportPhaseStartDate = null)
{
$this->m_oDataSource = $oDataSource;
$this->m_bIsImportPhaseDateKnown = ($oImportPhaseStartDate != null);
$this->m_oImportPhaseStartDate = $oImportPhaseStartDate;
$this->m_oCtx = new ContextTag(ContextTag::TAG_SYNCHRO);
$this->m_oCtx1 = new ContextTag('Synchro:'.$oDataSource->GetRawName()); // More precise context information
}
/**
* When in execution datasynchro phase, we are comparing date with the \SynchroReplica status_last_seen attribute. This attribute is
* populated using database trigger, who are therefore using the database datetime : in consequence we need database datetime as
* reference to do a proper comparison !
*
* @throws \MySQLException
* @throws \MySQLQueryHasNoResultException
* @throws \Exception
*/
public static function GetDataBaseCurrentDateTime()
{
$sDataBaseCurrentDateTime = CMDBSource::QueryToScalar('SELECT NOW()');
return new DateTime($sDataBaseCurrentDateTime);
}
/**
* Create the persistent information records, for the current synchronization
* In fact, those records ARE defining what is the "current" synchronization
*/
protected function PrepareLogs()
{
if (!is_null($this->m_oChange)) {
return;
}
// Create a change used for logging all the modifications/creations happening during the synchro
$this->m_oChange = MetaModel::NewObject('CMDBChange');
$this->m_oChange->Set('date', time());
$sUserString = CMDBChange::GetCurrentUserName();
$this->m_oChange->Set('userinfo', $sUserString.' '.Dict::S('Core:SyncDataExchangeComment'));
$this->m_oChange->Set('origin', 'synchro-data-source');
$this->m_oChange->DBInsert();
CMDBObject::SetCurrentChange($this->m_oChange);
// Start logging this execution (stats + protection against reentrance)
//
$this->m_oStatLog = new SynchroLog();
$this->m_oStatLog->Set('sync_source_id', $this->m_oDataSource->GetKey());
$this->m_oStatLog->Set('start_date', time());
$this->m_oStatLog->Set('status', 'running');
$this->m_oStatLog->Set('stats_nb_replica_seen', 0);
$this->m_oStatLog->Set('stats_nb_replica_total', 0);
$this->m_oStatLog->Set('stats_nb_obj_deleted', 0);
$this->m_oStatLog->Set('stats_nb_obj_deleted_errors', 0);
$this->m_oStatLog->Set('stats_nb_obj_obsoleted', 0);
$this->m_oStatLog->Set('stats_nb_obj_obsoleted_errors', 0);
$this->m_oStatLog->Set('stats_nb_obj_created', 0);
$this->m_oStatLog->Set('stats_nb_obj_created_errors', 0);
$this->m_oStatLog->Set('stats_nb_obj_created_warnings', 0);
$this->m_oStatLog->Set('stats_nb_obj_updated', 0);
$this->m_oStatLog->Set('stats_nb_obj_updated_warnings', 0);
$this->m_oStatLog->Set('stats_nb_obj_updated_errors', 0);
$this->m_oStatLog->Set('stats_nb_obj_unchanged_warnings', 0);
// $this->m_oStatLog->Set('stats_nb_replica_reconciled', 0);
$this->m_oStatLog->Set('stats_nb_replica_reconciled_errors', 0);
$this->m_oStatLog->Set('stats_nb_replica_disappeared_no_action', 0);
$this->m_oStatLog->Set('stats_nb_obj_new_updated', 0);
$this->m_oStatLog->Set('stats_nb_obj_new_updated_warnings', 0);
$this->m_oStatLog->Set('stats_nb_obj_new_unchanged', 0);
$this->m_oStatLog->Set('stats_nb_obj_new_unchanged_warnings', 0);
$sSelectTotal = 'SELECT SynchroReplica WHERE sync_source_id = :source_id';
$oSetTotal = new DBObjectSet(
DBObjectSearch::FromOQL($sSelectTotal),
[] /* order by*/,
['source_id' => $this->m_oDataSource->GetKey()]
);
$this->m_iCountAllReplicas = $oSetTotal->Count();
$this->m_oStatLog->Set('stats_nb_replica_total', $this->m_iCountAllReplicas);
$this->m_oStatLog->DBInsert();
$sLastFullLoad = ($this->m_bIsImportPhaseDateKnown) ? $this->m_oImportPhaseStartDate->format('Y-m-d H:i:s') : 'not specified';
$this->m_oStatLog->AddTrace("###### STARTING SYNCHRONIZATION ##### Total: {$this->m_iCountAllReplicas} replica(s). Last full load: '$sLastFullLoad' ");
$sSql = 'SELECT NOW();';
$sDBNow = CMDBSource::QueryToScalar($sSql);
$this->m_oStatLog->AddTrace("Database server current date/time is '$sDBNow', web server current date/time is: '".date('Y-m-d H:i:s')."'");
}
/**
* Prevent against the reentrance... or allow the current task to do things forbidden by the others !
*/
public static $m_oCurrentTask = null;
public static function GetCurrentTaskId()
{
if (is_object(self::$m_oCurrentTask)) {
return self::$m_oCurrentTask->GetKey();
} else {
return null;
}
}
/**
* Prepare structures in memory, to speedup the processing of a given replica
*
* @param bool $bFirstPass
*
* @throws \CoreException
* @throws \CoreUnexpectedValue
* @throws \MySQLException
* @throws \OQLException
* @throws \SynchroExceptionNotStarted
*/
public function PrepareProcessing($bFirstPass = true)
{
if ($this->m_oDataSource->Get('status') == 'obsolete') {
throw new SynchroExceptionNotStarted(Dict::S('Core:SyncDataSourceObsolete'));
}
if (!UserRights::IsAdministrator() && $this->m_oDataSource->Get('user_id') != UserRights::GetUserId()) {
throw new SynchroExceptionNotStarted(Dict::S('Core:SyncDataSourceAccessRestriction'));
}
// Get the list of SQL columns
$aAttCodesExpected = [];
$aAttCodesToReconcile = [];
$aAttCodesToUpdate = [];
$sSelectAtt = 'SELECT SynchroAttribute WHERE sync_source_id = :source_id AND (update = 1 OR reconcile = 1)';
$oSetAtt = new DBObjectSet(
DBObjectSearch::FromOQL($sSelectAtt),
[] /* order by*/,
['source_id' => $this->m_oDataSource->GetKey()] /* aArgs */
);
while ($oSyncAtt = $oSetAtt->Fetch()) {
if ($oSyncAtt->Get('update')) {
$aAttCodesToUpdate[$oSyncAtt->Get('attcode')] = $oSyncAtt;
}
if ($oSyncAtt->Get('reconcile')) {
$aAttCodesToReconcile[$oSyncAtt->Get('attcode')] = $oSyncAtt;
}
$aAttCodesExpected[$oSyncAtt->Get('attcode')] = $oSyncAtt;
}
$aColumns = $this->m_oDataSource->GetSQLColumns(array_keys($aAttCodesExpected));
$aExtDataFields = array_keys($aColumns);
$aExtDataFields[] = 'primary_key';
$this->m_aExtDataSpec = [
'table' => $this->m_oDataSource->GetDataTable(),
'join_key' => 'id',
'fields' => $aExtDataFields,
];
// Get the list of attributes, determine reconciliation keys and update targets
//
if ($this->m_oDataSource->Get('reconciliation_policy') == 'use_attributes') {
$this->m_aReconciliationKeys = $aAttCodesToReconcile;
} elseif ($this->m_oDataSource->Get('reconciliation_policy') == 'use_primary_key') {
// Override the settings made at the attribute level !
$this->m_aReconciliationKeys = ['primary_key' => null];
}
if ($bFirstPass) {
$this->m_oStatLog->AddTrace('Update of: {'.implode(', ', array_keys($aAttCodesToUpdate)).'}');
$this->m_oStatLog->AddTrace('Reconciliation on: {'.implode(', ', array_keys($this->m_aReconciliationKeys)).'}');
}
if (count($aAttCodesToUpdate) == 0) {
$this->m_oStatLog->AddTrace('No attribute to update');
throw new SynchroExceptionNotStarted('There is no attribute to update');
}
if (count($this->m_aReconciliationKeys) == 0) {
$this->m_oStatLog->AddTrace('No attribute for reconciliation');
throw new SynchroExceptionNotStarted('No attribute for reconciliation');
}
$this->m_aAttributes = [];
foreach ($aAttCodesToUpdate as $sAttCode => $oSyncAtt) {
$oAttDef = MetaModel::GetAttributeDef($this->m_oDataSource->GetTargetClass(), $sAttCode);
if ($oAttDef->IsWritable()) {
$this->m_aAttributes[$sAttCode] = $oSyncAtt;
}
}
// Compute and keep track of the limit date taken into account for obsoleting replicas
//
$iFullLoadInterval = $this->m_oDataSource->Get('full_load_periodicity'); // Duration in seconds
if ($this->m_bIsImportPhaseDateKnown) {
$oLimitDate = clone $this->m_oImportPhaseStartDate;
$sInterval = "-$iFullLoadInterval seconds";
$oLimitDate->Modify($sInterval);
} else {
if ($iFullLoadInterval <= 0) {
// we are doing exec phase alone, and the full load interval is set to 0 => we should not update/delete replicas !!
// This will prevent actions in DoJob1() method
$oLimitDate = new DateTime('1970-01-01');
} else {
$oLimitDate = self::GetDataBaseCurrentDateTime();
$sInterval = "-$iFullLoadInterval seconds";
$oLimitDate->Modify($sInterval);
}
}
$this->m_oLastFullLoadStartDate = $oLimitDate;
if ($bFirstPass) {
$this->m_oStatLog->AddTrace('Limit Date: '.$this->m_oLastFullLoadStartDate->Format('Y-m-d H:i:s'));
}
}
/**
* Perform a synchronization between the data stored in the replicas (synchro_data_xxx_xx table)
* and the iTop objects.
*
* @return SynchroLog
* @throws \CoreUnexpectedValue
*/
public function Process()
{
$this->PrepareLogs();
self::$m_oCurrentTask = $this->m_oDataSource;
$oMutex = new iTopMutex('synchro_process_'.$this->m_oDataSource->GetKey());
try {
$oMutex->Lock();
$this->DoSynchronize();
$oMutex->Unlock();
$this->m_oStatLog->Set('end_date', time());
$this->m_oStatLog->Set('status', 'completed');
$this->m_oStatLog->DBUpdate();
$iErrors = $this->m_oStatLog->GetErrorCount();
if ($iErrors > 0) {
$sIssuesOQL = 'SELECT SynchroReplica WHERE sync_source_id='.$this->m_oDataSource->GetKey()." AND status_last_error!=''";
$sAbsoluteUrl = utils::GetAbsoluteUrlAppRoot();
$sIssuesURL = "{$sAbsoluteUrl}synchro/replica.php?operation=oql&datasource=".$this->m_oDataSource->GetKey().'&oql='.urlencode($sIssuesOQL);
$sStatistics = "<h1>Statistics</h1>\n";
$sStatistics .= "<ul>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('start_date').': '.$this->m_oStatLog->Get('start_date')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('end_date').': '.$this->m_oStatLog->Get('end_date')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_replica_seen').': '.$this->m_oStatLog->Get('stats_nb_replica_seen')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_replica_total').': '.$this->m_oStatLog->Get('stats_nb_replica_total')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_obj_deleted').': '.$this->m_oStatLog->Get('stats_nb_obj_deleted')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_obj_deleted_errors').': '.$this->m_oStatLog->Get('stats_nb_obj_deleted_errors')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_obj_obsoleted').': '.$this->m_oStatLog->Get('stats_nb_obj_obsoleted')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_obj_obsoleted_errors').': '.$this->m_oStatLog->Get('stats_nb_obj_obsoleted_errors')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_obj_created').': '.$this->m_oStatLog->Get('stats_nb_obj_created').' ('.$this->m_oStatLog->Get('stats_nb_obj_created_warnings').' warnings)'."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_obj_created_errors').': '.$this->m_oStatLog->Get('stats_nb_obj_created_errors')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_obj_updated').': '.$this->m_oStatLog->Get('stats_nb_obj_updated').' ('.$this->m_oStatLog->Get('stats_nb_obj_updated_warnings').' warnings)'."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_obj_updated_errors').': '.$this->m_oStatLog->Get('stats_nb_obj_updated_errors')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_replica_reconciled_errors').': '.$this->m_oStatLog->Get('stats_nb_replica_reconciled_errors')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_replica_disappeared_no_action').': '.$this->m_oStatLog->Get('stats_nb_replica_disappeared_no_action')."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_obj_new_updated').': '.$this->m_oStatLog->Get('stats_nb_obj_new_updated').' ('.$this->m_oStatLog->Get('stats_nb_obj_new_updated_warnings').' warnings)'."</li>\n";
$sStatistics .= '<li>'.$this->m_oStatLog->GetLabel('stats_nb_obj_new_unchanged').': '.$this->m_oStatLog->Get('stats_nb_obj_new_unchanged').' ('.$this->m_oStatLog->Get('stats_nb_obj_new_unchanged_warnings').' warnings)'."</li>\n";
$sStatistics .= "</ul>\n";
$this->m_oDataSource->SendNotification(
"errors ($iErrors)",
"<p>The synchronization has been executed, $iErrors errors have been encountered. Click <a href=\"$sIssuesURL\">here</a> to see the records being currently in error.</p>".$sStatistics
);
} else {
//$this->m_oDataSource->SendNotification('success', '<p>The synchronization has been successfully executed.</p>');
}
} catch (SynchroExceptionNotStarted $e) {
$oMutex->Unlock();
// Set information for reporting... but delete the object in DB
$this->m_oStatLog->Set('end_date', time());
$this->m_oStatLog->Set('status', 'error');
$this->m_oStatLog->Set('last_error', $e->getMessage());
$this->m_oStatLog->DBDelete();
$this->m_oDataSource->SendNotification(
'fatal error',
'<p>The synchronization could not start: \''.$e->getMessage().'\'</p><p>Please check its configuration</p>'
);
} catch (Exception $e) {
$oMutex->Unlock();
$this->m_oStatLog->Set('end_date', time());
$this->m_oStatLog->Set('status', 'error');
$this->m_oStatLog->Set('last_error', $e->getMessage());
$this->m_oStatLog->DBUpdate();
$this->m_oDataSource->SendNotification(
'exception',
'<p>The synchronization has been interrupted: \''.$e->getMessage().'\'</p><p>Please contact the application support team</p>'
);
}
self::$m_oCurrentTask = null;
return $this->m_oStatLog;
}
/**
* Do the execution phase
*
* @throws \CoreCannotSaveObjectException
* @throws \CoreException
* @throws \CoreUnexpectedValue
* @throws \MissingQueryArgument
* @throws \MySQLException
* @throws \MySQLHasGoneAwayException
* @throws \OQLException
* @throws \SynchroExceptionNotStarted
*/
protected function DoSynchronize()
{
$this->m_oStatLog->Set('status_curr_job', 1);
$this->m_oStatLog->Set('status_curr_pos', -1);
$iMaxChunkSize = utils::ReadParam('max_chunk_size', 0, true /* allow CLI */);
if ($iMaxChunkSize > 0) {
// Split the execution into several processes
// Each process will call DoSynchronizeChunk()
// The loop will end when a process does not reply "continue" on the last line of its output
if (!utils::IsModeCLI()) {
throw new SynchroExceptionNotStarted(Dict::S('Core:SyncSplitModeCLIOnly'));
}
$aArguments = [];
$aArguments['source'] = $this->m_oDataSource->GetKey();
$aArguments['log'] = $this->m_oStatLog->GetKey();
$aArguments['change'] = $this->m_oChange->GetKey();
$aArguments['chunk'] = $iMaxChunkSize;
if ($this->m_bIsImportPhaseDateKnown) {
$aArguments['last_full_load'] = $this->m_oImportPhaseStartDate->Format('Y-m-d H:i:s');
} else {
$aArguments['last_full_load'] = '';
}
$this->m_oStatLog->DBUpdate();
$iStepCount = 0;
do {
$aArguments['step_count'] = $iStepCount;
$iStepCount++;
set_time_limit(0); // On Linux the time spent outside of the script does not count, but on Windows it does, so let give us time !
list($iRes, $aOut) = utils::ExecITopScript('synchro/priv_sync_chunk.php', $aArguments);
// Reload the log that has been modified by the processes
$this->m_oStatLog->Reload();
$sLastRes = strtolower(trim(end($aOut)));
switch ($sLastRes) {
case 'continue':
$bContinue = true;
break;
case 'finished':
$bContinue = false;
break;
default:
$this->m_oStatLog->AddTrace('The script did not reply with the expected keywords:');
$aIndentedOut = [];
foreach ($aOut as $sOut) {
$aIndentedOut[] = "-> $sOut";
$this->m_oStatLog->AddTrace(">>> $sOut");
}
throw new Exception("Encountered an error in an underspinned process:\n".implode("\n", $aIndentedOut));
}
} while ($bContinue);
} else {
$this->PrepareProcessing(/* first pass */);
$this->DoJob1UpdateReplicas();
$this->DoJob2CreateOrUpdateItopObjects();
$this->DoJob3DeleteItopObjectsAndReplicas();
}
}
/**
* Do the synchronization job, limited to some amount of work
* This verb has been designed to be called from within a separate process
*
* @param \SynchroLog $oLog
* @param \CMDBChange $oChange
* @param int $iMaxChunkSize
*
* @return true if the process has to be continued
* @throws \CoreException
* @throws \CoreUnexpectedValue
* @throws \MissingQueryArgument
* @throws \MySQLException
* @throws \MySQLHasGoneAwayException
* @throws \OQLException
* @throws \SynchroExceptionNotStarted
*/
public function DoSynchronizeChunk($oLog, $oChange, $iMaxChunkSize)
{
// Initialize the structures...
self::$m_oCurrentTask = $this->m_oDataSource;
$this->m_oStatLog = $oLog;
$this->m_oChange = $oChange;
CMDBObject::SetCurrentChange($this->m_oChange);
// Prepare internal structures (not the first pass)
$this->PrepareProcessing(false);
$iCurrJob = $this->m_oStatLog->Get('status_curr_job');
$iCurrPos = $this->m_oStatLog->Get('status_curr_pos');
$this->m_oStatLog->AddTrace("Synchronizing chunk - curr_job:$iCurrJob, curr_pos:$iCurrPos, max_chunk_size:$iMaxChunkSize");
switch ($iCurrJob) {
case 1:
default:
$this->DoJob1UpdateReplicas($iMaxChunkSize, $iCurrPos);
$bContinue = true;
break;
case 2:
$this->DoJob2CreateOrUpdateItopObjects($iMaxChunkSize, $iCurrPos);
$bContinue = true;
break;
case 3:
$bContinue = $this->DoJob3DeleteItopObjectsAndReplicas($iMaxChunkSize, $iCurrPos);
break;
}
$this->m_oStatLog->DBUpdate();
self::$m_oCurrentTask = null;
return $bContinue;
}
/**
* Do the synchronization job #1: Execute action on replicas "untouched" for some time
* - Obsolete entries if delete_policy is 'update' or 'update_then_delete'
* - Delete entries if delete_policy is 'delete'
*
* @param integer $iMaxReplica Limit the number of replicas to process
* @param integer $iCurrPos Current position where to resume the processing
*
* @return true if the process must be continued
* @throws \CoreException
* @throws \CoreUnexpectedValue
* @throws \MissingQueryArgument
* @throws \MySQLException
* @throws \MySQLHasGoneAwayException
* @throws \OQLException
* @throws \SynchroExceptionNotStarted
*/
protected function DoJob1UpdateReplicas($iMaxReplica = null, $iCurrPos = -1)
{
$this->m_oStatLog->AddTrace(">>> Beginning of DoJob1(\$iMaxReplica = $iMaxReplica, \$iCurrPos = $iCurrPos)");
$sLastFullLoadStartDate = $this->m_oLastFullLoadStartDate->Format('Y-m-d H:i:s');
$iLoopTimeLimit = MetaModel::GetConfig()->Get('max_execution_time_per_loop');
// Get all the replicas that were not seen in the last import and mark them as obsolete
$sDeletePolicy = $this->m_oDataSource->Get('delete_policy');
if ($sDeletePolicy !== 'ignore') {
$sSelectToObsolete = "SELECT SynchroReplica WHERE id > :curr_pos AND sync_source_id = :source_id AND status IN ('new', 'synchronized', 'modified', 'orphan') AND status_last_seen < :last_import";
$oSetScope = new DBObjectSet(DBObjectSearch::FromOQL($sSelectToObsolete), [] /* order by*/, [
'source_id' => $this->m_oDataSource->GetKey(),
'last_import' => $sLastFullLoadStartDate,
'curr_pos' => $iCurrPos,
]);
$iCountScope = $oSetScope->Count();
$sDebugOql = $oSetScope->GetFilter()->ToOQL(true);
$this->m_oStatLog->AddTrace("Searching for replicas to mark as obsolete using query: '$sDebugOql', returned $iCountScope replica(s).");
if (($this->m_iCountAllReplicas > 10) && ($this->m_iCountAllReplicas == $iCountScope) && MetaModel::GetConfig()->Get('synchro_prevent_delete_all')) {
throw new SynchroExceptionNotStarted(Dict::S('Core:SyncTooManyMissingReplicas'));
}
if ($iMaxReplica) {
// Consider a given subset, starting from replica iCurrPos, limited to the count of iMaxReplica
// The replica have to be ordered by id
$oSetToProcess = new DBObjectSet(DBObjectSearch::FromOQL($sSelectToObsolete), ['id' => true] /* order by*/, [
'source_id' => $this->m_oDataSource->GetKey(),
'last_import' => $sLastFullLoadStartDate,
'curr_pos' => $iCurrPos,
]);
$oSetToProcess->SetLimit($iMaxReplica);
} else {
$oSetToProcess = $oSetScope;
}
$iLastReplicaProcessed = -1;
/** @var SynchroReplica $oReplica */
while ($oReplica = $oSetToProcess->Fetch()) {
set_time_limit(intval($iLoopTimeLimit));
$iLastReplicaProcessed = $oReplica->GetKey();
switch ($sDeletePolicy) {
case 'update':
case 'update_then_delete':
$this->m_oStatLog->AddTrace("Destination object to be updated", $oReplica);
$aToUpdate = [];
$aToUpdateSpec = explode(
';',
$this->m_oDataSource->Get('delete_policy_update')
); //ex: 'status:obsolete;description:stopped',
foreach ($aToUpdateSpec as $sUpdateSpec) {
$aUpdateSpec = explode(':', $sUpdateSpec);
if (count($aUpdateSpec) == 2) {
$sAttCode = $aUpdateSpec[0];
$sValue = $aUpdateSpec[1];
$aToUpdate[$sAttCode] = $sValue;
}
}
$oReplica->Set('status_last_error', '');
if ($oReplica->Get('dest_id') == '') {
$oReplica->Set('status', 'obsolete');
$this->m_oStatLog->Inc('stats_nb_replica_disappeared_no_action');
} else {
$oReplica->UpdateDestObject($aToUpdate, $this->m_oChange, $this->m_oStatLog);
if ($oReplica->Get('status_last_error') == '') {
// Change the status of the replica IIF
$oReplica->Set('status', 'obsolete');
}
}
$oReplica->DBUpdate();
break;
case 'delete':
// delete_policy_retention is not used here only full_load_interval
$this->m_oStatLog->AddTrace("Destination object to be DELETED", $oReplica);
$oReplica->DeleteDestObject($this->m_oChange, $this->m_oStatLog);
break;
default:
$this->m_oStatLog->AddTrace("Unknown delete policy : $sDeletePolicy");
break;
}
}
if ($iMaxReplica) {
if ($iMaxReplica < $iCountScope) {
// Continue with this job!
$this->m_oStatLog->Set('status_curr_pos', $iLastReplicaProcessed);
$this->m_oStatLog->AddTrace("<<< End of DoJob1(\$iMaxReplica = $iMaxReplica, \$iCurrPos = $iCurrPos) (returning true => more replicas to process)");
return true;
}
}
} // if ($sDeletePolicy != 'ignore'
//Count "seen" objects
$sSelectSeen = "SELECT SynchroReplica WHERE sync_source_id = :source_id AND status IN ('new', 'synchronized', 'modified', 'orphan') AND status_last_seen >= :last_import";
$oSetSeen = new DBObjectSet(
DBObjectSearch::FromOQL($sSelectSeen),
[] /* order by*/,
['source_id' => $this->m_oDataSource->GetKey(), 'last_import' => $sLastFullLoadStartDate]
);
$this->m_oStatLog->Set('stats_nb_replica_seen', $oSetSeen->Count());
// Job complete!
$this->m_oStatLog->Set('status_curr_job', 2);
$this->m_oStatLog->Set('status_curr_pos', -1);
$this->m_oStatLog->AddTrace("<<< End of DoJob1(\$iMaxReplica = $iMaxReplica, \$iCurrPos = $iCurrPos) (completed)");
return false;
}
/**
* Do the synchronization job #2: Create and modify object for new/modified replicas
*
* @param integer $iMaxReplica Limit the number of replicas to process
* @param integer $iCurrPos Current position where to resume the processing
*
* @return true if the process must be continued
* @throws \CoreCannotSaveObjectException
* @throws \CoreException
* @throws \CoreUnexpectedValue
* @throws \MissingQueryArgument
* @throws \MySQLException
* @throws \MySQLHasGoneAwayException
* @throws \OQLException
*/
protected function DoJob2CreateOrUpdateItopObjects($iMaxReplica = null, $iCurrPos = -1)
{
$this->m_oStatLog->AddTrace(">>> Beginning of DoJob2(\$iMaxReplica = $iMaxReplica, \$iCurrPos = $iCurrPos)");
$sLimitDate = $this->m_oLastFullLoadStartDate->Format('Y-m-d H:i:s');
$this->m_oStatLog->AddTrace("\$sLimitDate = '$sLimitDate'");
$iLoopTimeLimit = MetaModel::GetConfig()->Get('max_execution_time_per_loop');
// Get all the replicas that are 'new' or modified or synchronized with a warning
//
$sSelectToSync = "SELECT SynchroReplica WHERE id > :curr_pos AND (status = 'new' OR status = 'modified' OR (status = 'synchronized' AND status_last_warning != '')) AND sync_source_id = :source_id AND status_last_seen >= :last_import";
$oSetScope = new DBObjectSet(DBObjectSearch::FromOQL($sSelectToSync), [], [
'source_id' => $this->m_oDataSource->GetKey(),
'last_import' => $sLimitDate,
'curr_pos' => $iCurrPos,
], $this->m_aExtDataSpec);
$iCountScope = $oSetScope->Count();
$sDebugOQL = $oSetScope->GetFilter()->ToOQL(true);
$this->m_oStatLog->AddTrace("Looking for - new, modified or synchonized with a warning - replicas using the OQL query: '$sDebugOQL', returned $iCountScope replicas.");
if ($iMaxReplica) {
// Consider a given subset, starting from replica iCurrPos, limited to the count of iMaxReplica
// The replica have to be ordered by id
$oSetToProcess = new DBObjectSet(
DBObjectSearch::FromOQL($sSelectToSync),
['id' => true] /* order by*/,
['source_id' => $this->m_oDataSource->GetKey(), 'last_import' => $sLimitDate, 'curr_pos' => $iCurrPos],
$this->m_aExtDataSpec
);
$oSetToProcess->SetLimit($iMaxReplica);
} else {
$oSetToProcess = $oSetScope;
}
// Avoid too many events
cmdbAbstractObject::SetEventDBLinksChangedBlocked(true);
try {
$iLastReplicaProcessed = -1;
/** @var \SynchroReplica $oReplica */
while ($oReplica = $oSetToProcess->Fetch()) {
set_time_limit(intval($iLoopTimeLimit));
$iLastReplicaProcessed = $oReplica->GetKey();
$this->m_oStatLog->AddTrace("Synchronizing replica id=$iLastReplicaProcessed.");
$oReplica->Synchro(
$this->m_oDataSource,
$this->m_aReconciliationKeys,
$this->m_aAttributes,
$this->m_oChange,
$this->m_oStatLog
);
$this->m_oStatLog->AddTrace("Updating replica id=$iLastReplicaProcessed.");
$oReplica->DBUpdate();
}
} finally {
// Send all the retained events for further computations
cmdbAbstractObject::SetEventDBLinksChangedBlocked(false);
cmdbAbstractObject::FireEventDbLinksChangedForAllObjects();
}
if ($iMaxReplica) {
if ($iMaxReplica < $iCountScope) {
// Continue with this job!
$this->m_oStatLog->Set('status_curr_pos', $iLastReplicaProcessed);
$this->m_oStatLog->AddTrace("<<< End of DoJob2(\$iMaxReplica = $iMaxReplica, \$iCurrPos = $iCurrPos) (returning true => more replicas to process)");
return true;
}
}
// Job complete!
$this->m_oStatLog->Set('status_curr_job', 3);
$this->m_oStatLog->Set('status_curr_pos', -1);
$this->m_oStatLog->AddTrace("<<< End of DoJob2(\$iMaxReplica = $iMaxReplica, \$iCurrPos = $iCurrPos) (completed)");
return false;
}
/**
* Do the synchronization job #3: Delete replica depending on the obsolescence scheme if delete_policy is 'update_then_delete'
*
* @param integer $iMaxReplica Limit the number of replicas to process
* @param integer $iCurrPos Current position where to resume the processing
*
* @return true if the process must be continued
* @throws \ArchivedObjectException
* @throws \CoreException
* @throws \CoreUnexpectedValue
* @throws \MissingQueryArgument
* @throws \MySQLException
* @throws \MySQLHasGoneAwayException
* @throws \OQLException
*/
protected function DoJob3DeleteItopObjectsAndReplicas($iMaxReplica = null, $iCurrPos = -1)
{
$this->m_oStatLog->AddTrace(">>> Beginning of DoJob3(\$iMaxReplica = $iMaxReplica, \$iCurrPos = $iCurrPos)");
$iLoopTimeLimit = MetaModel::GetConfig()->Get('max_execution_time_per_loop');
$sDeletePolicy = $this->m_oDataSource->Get('delete_policy');
if ($sDeletePolicy !== 'update_then_delete') {
$this->m_oStatLog->AddTrace("\$sDeletePoliciy = $sDeletePolicy != 'update_then_delete', nothing to do!");
// Job complete!
$this->m_oStatLog->Set('status_curr_job', 0);
$this->m_oStatLog->Set('status_curr_pos', -1);
$this->m_oStatLog->AddTrace("<<< End of DoJob3(\$iMaxReplica = $iMaxReplica, \$iCurrPos = $iCurrPos) (completed)");
return false;
}
$bFirstPass = ($iCurrPos === -1);
// Get all the replicas that are to be deleted
//
$oDeletionDate = $this->m_oLastFullLoadStartDate;
$iDeleteRetention = $this->m_oDataSource->Get('delete_policy_retention'); // Duration in seconds
if ($iDeleteRetention > 0) {
$sInterval = "-$iDeleteRetention seconds";
$oDeletionDate->Modify($sInterval);
}
$sDeletionDate = $oDeletionDate->Format('Y-m-d H:i:s');
if ($bFirstPass) {
$this->m_oStatLog->AddTrace("Deletion date: $sDeletionDate");
}
$sSelectToDelete = "SELECT SynchroReplica WHERE id > :curr_pos AND sync_source_id = :source_id AND status IN ('obsolete') AND status_last_seen < :last_import";
$oSetScope = new DBObjectSet(DBObjectSearch::FromOQL($sSelectToDelete), [], [
'source_id' => $this->m_oDataSource->GetKey(),
'last_import' => $sDeletionDate,
'curr_pos' => $iCurrPos,
]);
$iCountScope = $oSetScope->Count();
if ($iMaxReplica) {
// Consider a given subset, starting from replica iCurrPos, limited to the count of iMaxReplica
// The replica have to be ordered by id
$oSetToProcess = new DBObjectSet(
DBObjectSearch::FromOQL($sSelectToDelete),
['id' => true] /* order by*/,
['source_id' => $this->m_oDataSource->GetKey(), 'last_import' => $sDeletionDate, 'curr_pos' => $iCurrPos]
);
$oSetToProcess->SetLimit($iMaxReplica);
} else {
$oSetToProcess = $oSetScope;
}
$iLastReplicaProcessed = -1;
/** @var SynchroReplica $oReplica */
while ($oReplica = $oSetToProcess->Fetch()) {
set_time_limit(intval($iLoopTimeLimit));
$iLastReplicaProcessed = $oReplica->GetKey();
$this->m_oStatLog->AddTrace('Destination object to be DELETED', $oReplica);
$oReplica->DeleteDestObject($this->m_oChange, $this->m_oStatLog);
}
if ($iMaxReplica) {
if ($iMaxReplica < $iCountScope) {
// Continue with this job!
$this->m_oStatLog->Set('status_curr_pos', $iLastReplicaProcessed);
$this->m_oStatLog->AddTrace("<<< End of DoJob3\$iMaxReplica = $iMaxReplica, \$iCurrPos = $iCurrPos) (returning true => more replicas to process)");
return true;
}
}
// Job complete!
$this->m_oStatLog->Set('status_curr_job', 0);
$this->m_oStatLog->Set('status_curr_pos', -1);
$this->m_oStatLog->AddTrace("<<< End of DoJob3(\$iMaxReplica = $iMaxReplica, \$iCurrPos = $iCurrPos) (completed)");
return false;
}
}
Reference in New Issue View Git Blame Copy Permalink