for(std::vector<std::string>::iterator it = command_alias.begin();
        it != command_alias.end();
        it++) {
        SCACU_LAPP_ << "Add input attribute for slow command:" << *it;
        domain_attribute_setting.addAttribute(*it, 255, DataType::TYPE_STRING);
    }
}

void SCAbstractControlUnit::submitSlowCommand(const std::string command_alias,
                                              CDataWrapper *slow_command_pack,
                                              uint64_t& command_id) {
    CHAOS_ASSERT(slow_command_executor)
    slow_command_executor->submitCommand(command_alias,
                                         slow_command_pack,
                                         command_id);
}

/*
 Receive the event for set the dataset input element
 */
CDataWrapper* SCAbstractControlUnit::setDatasetAttribute(CDataWrapper *datasetAttributeValues, bool& detachParam) throw (CException) {
    uint64_t command_id =0;
    CDataWrapper *result = NULL;

    if(datasetAttributeValues->hasKey(chaos_batch::BatchCommandAndParameterDescriptionkey::BC_ALIAS)) {

        CHAOS_ASSERT(slow_command_executor)
        std::string command_alias = datasetAttributeValues->getStringValue(chaos_batch::BatchCommandAndParameterDescriptionkey::BC_ALIAS);
        // in slow control cu the CDataWrapper instance received from rpc is internally managed
        //so we need to detach it
        // submit the detacched command to slow controll subsystem
        slow_command_executor->submitCommand(command_alias,
                                             datasetAttributeValues,
                                             command_id);
        detachParam = true;
        //in this event the value is the alias of the command
        //publish command value
        AttributeValue *attr_value = attribute_value_shared_cache->getAttributeValue(DOMAIN_INPUT, command_alias);

        if(attr_value) {
            std::string cmd_param = datasetAttributeValues->getJSONString();
            //add new size
            attr_value->setNewSize((uint32_t)cmd_param.size());
            
            //set the value without notify because command value are managed internally only
            attr_value->setValue(cmd_param.c_str(), (uint32_t)cmd_param.size(), true);
            
            //push input dataset change
            pushInputDataset();
        }
        //construct the result

        result = new CDataWrapper();

        result->addInt64Value(chaos_batch::BatchCommandExecutorRpcActionKey::RPC_GET_COMMAND_STATE_CMD_ID_UI64, command_id);
    }

    return AbstractControlUnit::setDatasetAttribute(datasetAttributeValues, detachParam);
}

/*
 Event for update some CU configuration
 */
CDataWrapper* SCAbstractControlUnit::updateConfiguration(CDataWrapper *update_pack, bool& detach_param) throw (CException) {
    CDataWrapper *result = AbstractControlUnit::updateConfiguration(update_pack, detach_param);
    std::auto_ptr<CDataWrapper> cu_properties;
    CDataWrapper *cu_property_container = NULL;
    if(update_pack->hasKey(ControlUnitNodeDefinitionKey::THREAD_SCHEDULE_DELAY)){
        cu_property_container = update_pack;
    } else  if(update_pack->hasKey("property_abstract_control_unit") &&
               update_pack->isCDataWrapperValue("property_abstract_control_unit")){
        cu_properties.reset(update_pack->getCSDataValue("property_abstract_control_unit"));
        if(cu_properties->hasKey(ControlUnitNodeDefinitionKey::THREAD_SCHEDULE_DELAY)) {
            cu_property_container = cu_properties.get();
        }
    }
    
    if(cu_property_container) {
        //we need to configure the delay  from a run() call and the next
        uint64_t new_schedule_daly = cu_property_container->getUInt64Value(ControlUnitNodeDefinitionKey::THREAD_SCHEDULE_DELAY);
        chaos_batch::features::Features features;
        std::memset(&features, 0, sizeof(chaos_batch::features::Features));
        //features.featuresFlag &= chaos_batch::features::FeaturesFlagTypes::FF_LOCK_USER_MOD;
        features.featureSchedulerStepsDelay = new_schedule_daly;