#ifndef INSTALLER_LOG_H
#define INSTALLER_LOG_H
-#include <dlog.h>
#include <dpl/log/secure_log.h>
-#include <dpl/string.h>
#ifdef WRT_INSTALLER_LOG
#endif
-#define DPLToChar(DS) { DPL::ToUTF8String(DS).c_str() }
-
#endif // INSTALLER_LOG_H
#include <dpl/binary_queue.h>
#include <dpl/assert.h>
#include <dpl/file_input.h>
-#include <dpl/log/log.h>
+
+#include <installer_log.h>
class ParserRunner::Impl
{
va_start(args, msg);
vsnprintf(buffer, 300, msg, args);
va_end(args);
- LogError(buffer);
+ _E("%s", buffer);
}
static void logWarningLibxml2(void *, const char *msg, ...)
va_start(args, msg);
vsnprintf(buffer, 300, msg, args);
va_end(args);
- LogWarning(buffer);
+ _W("%s", buffer);
}
public:
xmlSchemaPtr xschema;
ctx = xmlSchemaNewParserCtxt(schema.c_str());
if (ctx == NULL) {
- LogError("xmlSchemaNewParserCtxt() Failed");
+ _E("xmlSchemaNewParserCtxt() Failed");
return false;
}
xschema = xmlSchemaParse(ctx);
if (xschema == NULL) {
- LogError("xmlSchemaParse() Failed");
+ _E("xmlSchemaParse() Failed");
return false;
}
vctx = xmlSchemaNewValidCtxt(xschema);
if (vctx == NULL) {
- LogError("xmlSchemaNewValidCtxt() Failed");
+ _E("xmlSchemaNewValidCtxt() Failed");
return false;
}
xmlSchemaSetValidErrors(vctx, (xmlSchemaValidityErrorFunc)&logErrorLibxml2, (xmlSchemaValidityWarningFunc) &logWarningLibxml2, NULL);
ret = xmlSchemaValidateFile(vctx, filename.c_str(), 0);
if (ret == -1) {
- LogError("xmlSchemaValidateFile() failed");
+ _E("xmlSchemaValidateFile() failed");
return false;
} else if (ret == 0) {
- LogError("Config is Valid");
+ _E("Config is Valid");
return true;
} else {
- LogError("Config Validation Failed with error code " << ret);
+ _E("Config Validation Failed with error code %d", ret);
return false;
}
return true;
break;
}
default:
- LogWarning("Ignoring Node of Type: " <<
- xmlTextReaderNodeType(m_reader));
+ _W("Ignoring Node of Type: %d", xmlTextReaderNodeType(m_reader));
break;
}
if (m_parsingError) {
- LogError("Parsing error occured: " << m_errorMsg);
+ _E("Parsing error occured: %ls", m_errorMsg.c_str());
ThrowMsg(ElementParser::Exception::ParseError, m_errorMsg);
}
}
if (m_parsingError) {
- LogError("Parsing error occured: " << m_errorMsg);
+ _E("Parsing error occured: %ls", m_errorMsg.c_str());
ThrowMsg(ElementParser::Exception::ParseError, m_errorMsg);
}
Catch(ElementParser::Exception::Base)
{
CleanupParserRunner();
- LogError(_rethrown_exception.DumpToString());
+ _E("%s", _rethrown_exception.DumpToString().c_str());
ReThrow(ElementParser::Exception::ParseError);
}
CleanupParserRunner();
element.lang = GetLanguageTag();
element.ns = GetNamespace();
- LogDebug("value: " << element.value <<
- ", lang: " << element.lang <<
- ", ns: " << element.ns << ")");
+ _D("value: %ls, lang: %ls, ns: %ls)",
+ element.value.c_str(), element.lang.c_str(), element.ns.c_str());
parser->Accept(element);
ParseNodeElementAttributes(parser);
void ParseNodeElementAttributes(const ElementParserPtr& parser)
{
Assert(m_reader);
-
int count = xmlTextReaderAttributeCount(m_reader);
for (int i = 0; i < count; ++i) {
xmlTextReaderMoveToAttributeNo(m_reader, i);
attribute.name = GetNameWithoutNamespace();
attribute.value = GetValue();
attribute.lang = GetLanguageTag();
- LogDebug("Attribute name: " << attribute.name <<
- ", value: " << attribute.value <<
- ", prefix: " << attribute.prefix <<
- ", namespace: " << attribute.ns <<
- ", lang: " << attribute.lang);
+ _D("Attribute name: %ls, value: %ls, prefix: %ls, namespace: %ls, lang: %ls",
+ attribute.name.c_str(), attribute.value.c_str(), attribute.prefix.c_str(),
+ attribute.ns.c_str(), attribute.lang.c_str());
parser->Accept(attribute);
}
}
void ErrorHandler(const DPL::String& msg)
{
- LogError("LibXML: " << msg);
+ _E("LibXML: %ls", msg.c_str());
m_parsingError = true;
m_errorMsg = m_errorMsg + DPL::FromASCIIString("\n");
m_errorMsg = m_errorMsg + msg;
void StructuredErrorHandler(xmlErrorPtr error)
{
- LogError("LibXML: " << error->message);
+ _E("LibXML: %s", error->message);
m_parsingError = true;
m_errorMsg = m_errorMsg + DPL::FromASCIIString("\n");
m_errorMsg = m_errorMsg + DPL::FromUTF8String(error->message);
#ifndef _WRT_ENGINE_SRC_INSTALLERCORE_CONFIGURATION_PARSER_ROOT_PARSER_H_
#define _WRT_ENGINE_SRC_INSTALLERCORE_CONFIGURATION_PARSER_ROOT_PARSER_H_
-#include <dpl/log/log.h>
+#include <installer_log.h>
#include "element_parser.h"
template<typename ta_Parser>
virtual void Accept(const Element& /*element*/)
{
- LogDebug("element");
+ _D("element");
}
virtual void Accept(const XmlAttribute& /*attribute*/)
{
- LogDebug("attribute");
+ _D("attribute");
}
virtual void Accept(const Text& /*text*/)
{
- LogDebug("text");
+ _D("text");
}
virtual void Verify()
{
- LogDebug("");
+ _D("");
}
private:
#include "wrt-commons/i18n-dao-ro/i18n_dao_read_only.h"
#include <iri.h>
-#include <dpl/log/log.h>
#include <dpl/fast_delegate.h>
#include <dpl/foreach.h>
#include <dpl/scoped_ptr.h>
#include <cstdlib>
#include <locale>
+#include <installer_log.h>
+
using namespace WrtDB;
namespace Unicode {
} else if (L"rlo" == attribute.value) {
return RLO;
} else {
- LogWarning("dir attribute has wrong value:" << attribute.value);
+ _W("dir attribute has wrong value: %ls ", attribute.value.c_str());
return EMPTY;
}
}
AcceptWac(attribute);
break;
default:
- LogError("Error in Access tag - unknown standard.");
+ _E("Error in Access tag - unknown standard.");
break;
}
}
iri.set(m_strIRIOrigin, false);
if (!iri.isAccessDefinition()) {
- LogWarning("Access list element: " <<
- m_strIRIOrigin <<
- " is not acceptable by WARP" <<
- "standard and will be ignored!");
+ _W("Access list element: %ls is not acceptable by WARP standard and will be ignored!",
+ m_strIRIOrigin.c_str());
return;
}
VerifyWac();
break;
default:
- LogError("Error in Access tag - unknown standard.");
+ _E("Error in Access tag - unknown standard.");
break;
}
}
virtual void Verify()
{
if (m_src.IsNull()) {
- LogWarning("src attribute of icon element is mandatory - ignoring");
+ _W("src attribute of icon element is mandatory - ignoring");
return;
}
}
Catch(BadSrcError)
{
- LogWarning("src attribute is invalid: " << m_src);
+ _W("src attribute is invalid: %ls", (*m_src).c_str());
}
}
virtual void Verify()
{
if (m_name.IsNull()) {
- LogWarning("preference element must have name attribute");
+ _W("preference element must have name attribute");
return;
}
NormalizeString(m_name);
if (!m_value.IsNull() && *m_value == ignoreUri)
{
- LogDebug("exception : '" << *m_value << "' scheme will be ignored.");
+ _D("exception : '%ls' scheme will be ignored.", (*m_value).c_str());
m_value = DPL::OptionalString::Null;
}
{
m_data.m_uriList.insert(*m_value);
} else {
- LogDebug("Ignoring uri with name" <<
- DPL::ToUTF8String(*m_value));
+ _D("Ignoring uri with name %ls", (*m_value).c_str());
}
}
{
m_data.m_mimeList.insert(*m_value);
} else {
- LogDebug("Ignoring mime with name" <<
- DPL::ToUTF8String(*m_value));
+ _D("Ignoring mime with name %ls", (*m_value).c_str());
}
}
m_data.m_disposition =
ConfigParserData::AppControlInfo::Disposition::INLINE;
} else {
- LogDebug("Ignoring dispostion value " <<
- DPL::ToUTF8String(*m_value));
+ _D("Ignoring dispostion value %ls", (*m_value).c_str());
}
}
virtual void Accept(const Element& element)
{
- LogWarning("namespace for app service = " << element.ns);
+ _W("namespace for app service = %ls", element.ns.c_str());
if (element.ns == ConfigurationNamespace::W3CWidgetNamespaceName) {
ThrowMsg(Exception::ParseError,
"Wrong xml namespace for widget element");
{
if (m_src.IsNull())
{
- LogWarning("src attribute of splash element is mandatory - ignoring");
+ _W("src attribute of splash element is mandatory - ignoring");
return;
}
virtual void Verify()
{
if (m_src.IsNull()) {
- LogWarning(
- "src attribute of background element is mandatory - ignoring");
+ _W("src attribute of background element is mandatory - ignoring");
return;
}
{
m_properNamespace = true;
}
- LogDebug("element");
+ _D("element");
}
virtual void Accept(const XmlAttribute& attribute)
{
m_data.featuresList.insert(m_feature);
} else {
- LogDebug("Ignoring feature with name" <<
- DPL::ToUTF8String(m_feature.name));
+ _D("Ignoring feature with name %ls", m_feature.name.c_str());
}
}
}
{
m_data.privilegeList.insert(m_privilege);
} else {
- LogDebug("Ignoring privilege with name" <<
- DPL::ToUTF8String(m_privilege.name));
+ _D("Ignoring privilege with name %ls", m_privilege.name.c_str());
}
}
}
virtual void Verify()
{
if (m_name.IsNull()) {
- LogWarning(
- "name attribute of category element is mandatory - ignoring");
+ _W("name attribute of category element is mandatory - ignoring");
return;
}
{
std::pair<DPL::String, DPL::String> boxLabel;
if (m_label.empty()) {
- LogWarning("box-label element is empty");
+ _W("box-label element is empty");
boxLabel.first = DPL::FromUTF8String("");
boxLabel.second = DPL::FromUTF8String("");
m_data.m_label.push_back(boxLabel);
if (*height < 1) {
m_height = L"1";
- LogDebug("height attribute of pd element shouldn't be less than 1. Changed to 1 from " << *height);
+ _D("height attribute of pd element shouldn't be less than 1. Changed to 1 from %d", *height);
} else if (*height > 380){
m_height = L"380";
- LogDebug("height attribute of pd element shouldn't be greater than 380. Changed to 380 from " << *height);
+ _D("height attribute of pd element shouldn't be greater than 380. Changed to 380 from %d", *height);
}
m_data.m_pdSrc = m_src;
//set standard locale to fix decimal point mark - '.'
std::string currentLocale = setlocale(LC_NUMERIC, NULL);
if (NULL == setlocale(LC_NUMERIC, "C"))
- LogWarning("Failed to change locale to \"C\"");
+ _W("Failed to change locale to \"C\"");
double updatePeriod = strtod(tempStr.c_str(), &endptr);
//go back to previous locale
if (NULL == setlocale(LC_NUMERIC, currentLocale.c_str()))
- LogWarning("Failed to set previous locale");
+ _W("Failed to set previous locale");
if ((errno == ERANGE && (updatePeriod == -HUGE_VAL || updatePeriod == HUGE_VAL))
|| *endptr != '\0') {
ThrowMsg(Exception::ParseError,
"update-period attribute of app-widget element should be a number - ignoring. current value: " << m_updatePeriod);
} else if (updatePeriod < 1800.0) {
- LogDebug("update-period attribute of app-widget element shouldn't be less than 1800.0 - changed to 1800 from value: " << m_updatePeriod);
+ _D("update-period attribute of app-widget element shouldn't be less than 1800.0 - changed to 1800 from value: %ls", m_updatePeriod.c_str());
m_updatePeriod = L"1800.0";
}
}
m_data.allowNavigationEncountered = true;
if (m_origin.IsNull()) {
- LogWarning("data is empty");
+ _W("data is empty");
return;
}
// input origin should has schem and host
// in case of file scheme path is filled
// "http://"
- LogWarning("input origin isn't verified");
+ _W("input origin isn't verified");
continue;
}
DPL::String scheme = L"*";
virtual void Verify()
{
if (m_key.IsNull()) {
- LogWarning("metadata element must have key attribute");
+ _W("metadata element must have key attribute");
return;
}
NormalizeString(m_key);
ConfigParserData::Metadata metaData(m_key, m_value);
FOREACH(it, m_data.metadataList) {
if (!DPL::StringCompare(*it->key, *m_key)) {
- LogError("Key isn't unique");
+ _E("Key isn't unique");
return;
}
}
m_data.widget_id = attribute.value;
NormalizeString(m_data.widget_id);
} else {
- LogWarning("Widget id validation failed: " << attribute.value);
+ _W("Widget id validation failed: %ls", attribute.value.c_str());
}
} else if (attribute.name == L"version") {
m_version = attribute.value;
NormalizeString(m_version);
} else if (attribute.name == L"min-version") {
- LogDebug("min-version attribute was found. Value: " << attribute.value);
+ _D("min-version attribute was found. Value: %ls", attribute.value.c_str());
m_minVersion = attribute.value;
NormalizeString(m_minVersion);
m_data.minVersionRequired = m_minVersion;
NormalizeString(m_defaultlocale);
if( I18n::DB::I18nDAOReadOnly::IsValidSubTag
(attribute.value, RECORD_TYPE_LANGUAGE)) {
- LogDebug("Default Locale Found " << m_defaultlocale);
+ _D("Default Locale Found %ls", (*m_defaultlocale).c_str());
} else {
- LogWarning("Default Locate Is Invalid");
+ _W("Default Locate Is Invalid");
}
} else {
- LogWarning("Ignoring subsequent default locale");
+ _W("Ignoring subsequent default locale");
}
//Any other value consider as a namespace definition
} else if (attribute.name == L"xmlns" || attribute.prefix == L"xmlns") {
- LogDebug("Namespace domain: " << attribute.name);
- LogDebug("Namespace value: " << attribute.value);
+ _D("Namespace domain: %ls", attribute.name.c_str());
+ _D("Namespace value: %ls", attribute.value.c_str());
m_nameSpaces[attribute.name] = attribute.value;
} else {
- LogError("Unknown attirbute: namespace=" << attribute.ns <<
- ", name=" << attribute.name <<
- ", value=" << attribute.value);
+ _E("Unknown attirbute: namespace=%ls, name=%ls, value=%ls",
+ attribute.ns.c_str(), attribute.name.c_str(), attribute.value.c_str());
}
}
#include <plugin_install/plugin_install_task.h>
#include "plugin_objects.h"
#include <wrt_common_types.h>
+#include <installer_log.h>
namespace Jobs {
namespace PluginInstall {
void JobPluginInstall::SendProgress()
{
if (GetProgressFlag() && GetInstallerStruct().progressCallback != NULL) {
- LogDebug("Call Plugin install progressCallback");
+ _D("Call Plugin install progressCallback");
GetInstallerStruct().progressCallback(GetInstallerStruct().userParam,
GetProgressPercent(),
GetProgressDescription());
if (handle != Jobs::PluginInstall::JobPluginInstall::INVALID_HANDLE &&
isReadyToInstall())
{
- LogDebug("Call Plugin install success finishedCallback");
+ _D("Call Plugin install success finishedCallback");
GetInstallerStruct().finishedCallback(GetInstallerStruct().userParam,
Jobs::Exceptions::Success);
} else {
- LogDebug("Call Plugin install waiting finishedCallback");
+ _D("Call Plugin install waiting finishedCallback");
GetInstallerStruct().finishedCallback(GetInstallerStruct().userParam,
Jobs::Exceptions::ErrorPluginInstallationFailed);
- LogDebug("Installation: " << getFilePath() <<
- " NOT possible");
+ _D("Installation: %s NOT possible", getFilePath().c_str());
}
}
void JobPluginInstall::SendFinishedFailure()
{
- LogError("Error in plugin installation step: " << m_exceptionCaught);
- LogError("Message: " << m_exceptionMessage);
+ _E("Error in plugin installation step: %d", m_exceptionCaught);
+ _E("Message: %s", m_exceptionMessage.c_str());
- LogDebug("Call Plugin install failure finishedCallback");
+ _D("Call Plugin install failure finishedCallback");
GetInstallerStruct().finishedCallback(GetInstallerStruct().userParam,
m_exceptionCaught);
}
#include <dlfcn.h>
//WRT INCLUDES
-#include <dpl/log/log.h>
#include <dpl/foreach.h>
#include <job.h>
#include "plugin_install_task.h"
#include "plugin_objects.h"
#include <wrt_plugin_export.h>
#include <plugin_path.h>
+#include <installer_log.h>
using namespace WrtDB;
#define DISABLE_IF_PLUGIN_WITHOUT_LIB() \
if (m_pluginInfo.m_libraryName.empty()) \
{ \
- LogWarning("Plugin without library."); \
+ _W("Plugin without library."); \
return; \
}
void PluginInstallTask::stepCheckPluginPath()
{
- LogDebug("Plugin installation: step CheckPluginPath");
+ _D("Plugin installation: step CheckPluginPath");
if(!m_context->pluginFilePath.Exists()){
ThrowMsg(Exceptions::PluginPathFailed,
void PluginInstallTask::stepParseConfigFile()
{
- LogDebug("Plugin installation: step parse config file");
+ _D("Plugin installation: step parse config file");
if(!m_context->pluginFilePath.getMetaFile().Exists()){
m_dataFromConfigXML = false;
return;
}
- LogInfo("Plugin Config file::" << m_context->pluginFilePath.getMetaFile());
+ _D("Plugin Config file::%s", m_context->pluginFilePath.getMetaFile().Fullpath().c_str());
Try
{
FOREACH(it, m_pluginInfo.m_featureContainer)
{
- LogDebug("Parsed feature : " << it->m_name);
+ _D("Parsed feature : %s", it->m_name.c_str());
FOREACH(devCap, it->m_deviceCapabilities) {
- LogDebug(" | DevCap : " << *devCap);
+ _D(" | DevCap : %s", (*devCap).c_str());
}
}
}
Catch(ValidationCore::ParserSchemaException::Base)
{
- LogError("Error during file processing " <<
- m_context->pluginFilePath.getMetaFile());
+ _E("Error during file processing %s", m_context->pluginFilePath.getMetaFile().Fullpath().c_str());
ThrowMsg(Exceptions::PluginMetafileFailed,
"Metafile error");
}
if (m_dataFromConfigXML) {
return;
}
- LogDebug("Plugin installation: step find plugin library");
- LogDebug("Plugin .so: " << m_context->pluginFilePath.getLibraryName());
+ _D("Plugin installation: step find plugin library");
+ _D("Plugin .so: %s", m_context->pluginFilePath.getLibraryName().c_str());
m_pluginInfo.m_libraryName = m_context->pluginFilePath.getLibraryName();
}
void PluginInstallTask::stepLoadPluginLibrary()
{
- LogDebug("Plugin installation: step load library");
+ _D("Plugin installation: step load library");
DISABLE_IF_PLUGIN_WITHOUT_LIB()
- LogDebug("Loading plugin: " << m_context->pluginFilePath.getLibraryName());
+ _D("Loading plugin: %s", m_context->pluginFilePath.getLibraryName().c_str());
fprintf(stderr, " - Try to dlopen() : [%s] ", m_context->pluginFilePath.getLibraryPath().Fullpath().c_str());
fprintf(stderr,
"-> Failed!\n %s\n",
(error != NULL ? error : "unknown"));
- LogError(
- "Failed to load plugin: " << m_context->pluginFilePath.getLibraryName() <<
- ". Reason: " << (error != NULL ? error : "unknown"));
+ _E("Failed to load plugin: %s. Reason: %s",
+ m_context->pluginFilePath.getLibraryName().c_str(), (error != NULL ? error : "unknown"));
ThrowMsg(Exceptions::PluginLibraryError, "Library error");
}
if (rawEntityList == NULL) {
dlclose(dlHandle);
- LogError("Failed to read class name" << m_context->pluginFilePath.getLibraryName());
+ _E("Failed to read class name %s", m_context->pluginFilePath.getLibraryName().c_str());
ThrowMsg(Exceptions::PluginLibraryError, "Library error");
}
if (NULL == onWidgetInitProc) {
dlclose(dlHandle);
- LogError("Failed to read onWidgetInit symbol" << m_context->pluginFilePath.getLibraryName());
+ _E("Failed to read onWidgetInit symbol %s", m_context->pluginFilePath.getLibraryName().c_str());
ThrowMsg(Exceptions::PluginLibraryError, "Library error");
}
if (!mappingInterface.featGetter || !mappingInterface.release ||
!mappingInterface.dcGetter)
{
- LogError("Failed to obtain mapping interface from .so");
+ _E("Failed to obtain mapping interface from .so");
ThrowMsg(Exceptions::PluginLibraryError, "Library error");
}
feature_mapping_t* devcapMapping = mappingInterface.featGetter();
- LogDebug("Getting mapping from features to device capabilities");
+ _D("Getting mapping from features to device capabilities");
for (size_t i = 0; i < devcapMapping->featuresCount; ++i) {
PluginMetafileData::Feature feature;
feature.m_name = devcapMapping->features[i].feature_name;
- LogDebug("Feature: " << feature.m_name);
+ _D("Feature: %s", feature.m_name.c_str());
const devcaps_t* dc =
mappingInterface.dcGetter(
devcapMapping->features[i].
feature_name);
- LogDebug("device=cap: " << dc);
-
if (dc) {
- LogDebug("devcaps count: " << dc->devCapsCount);
+ _D("devcaps count: %d", dc->devCapsCount);
for (size_t j = 0; j < dc->devCapsCount; ++j) {
- LogDebug("devcap: " << dc->deviceCaps[j]);
+ _D("devcap: %s", dc->deviceCaps[j]);
feature.m_deviceCapabilities.insert(dc->deviceCaps[j]);
}
}
m_libraryObjects = PluginObjectsPtr(new PluginObjects());
const js_entity_definition_t *rawEntityListIterator = rawEntityList;
- LogDebug("#####");
- LogDebug("##### Plugin: "
- << m_context->pluginFilePath.getLibraryName()
- << " supports new plugin API");
- LogDebug("#####");
+ _D("#####");
+ _D("##### Plugin: %s supports new plugin API",
+ m_context->pluginFilePath.getLibraryName().c_str());
+ _D("#####");
while (rawEntityListIterator->parent_name != NULL &&
rawEntityListIterator->object_name != NULL)
{
- LogDebug("##### [" << rawEntityListIterator->object_name << "]: ");
- LogDebug("##### Parent: " << rawEntityListIterator->parent_name);
- LogDebug("#####");
+ _D("##### [%s]: ", rawEntityListIterator->object_name);
+ _D("##### Parent: %s", rawEntityListIterator->parent_name);
+ _D("#####");
m_libraryObjects->addObjects(rawEntityListIterator->parent_name,
rawEntityListIterator->object_name);
// Unload library
if (dlclose(dlHandle) != 0) {
- LogError("Cannot close plugin handle");
+ _E("Cannot close plugin handle");
} else {
- LogDebug("Library is unloaded");
+ _D("Library is unloaded");
}
// Load export table
- LogDebug("Library successfuly loaded and parsed");
+ _D("Library successfuly loaded and parsed");
SET_PLUGIN_INSTALL_PROGRESS(LOADING_LIBRARY, "Library loaded and analyzed");
}
void PluginInstallTask::stepRegisterPlugin()
{
- LogDebug("Plugin installation: step register Plugin");
+ _D("Plugin installation: step register Plugin");
m_pluginHandle =
PluginDAO::registerPlugin(m_pluginInfo, m_context->pluginFilePath.Fullpath());
void PluginInstallTask::stepRegisterFeatures()
{
- LogDebug("Plugin installation: step register features");
+ _D("Plugin installation: step register features");
FOREACH(it, m_pluginInfo.m_featureContainer)
{
- LogDebug("PluginHandle: " << m_pluginHandle);
+ _D("PluginHandle: %d", m_pluginHandle);
FeatureDAO::RegisterFeature(*it, m_pluginHandle);
}
SET_PLUGIN_INSTALL_PROGRESS(REGISTER_FEATURES, "Features registered");
void PluginInstallTask::stepRegisterPluginObjects()
{
- LogDebug("Plugin installation: step register objects");
+ _D("Plugin installation: step register objects");
DISABLE_IF_PLUGIN_WITHOUT_LIB()
FOREACH(it, *objects)
{
if (m_libraryObjects->hasObject(*it)) {
- LogDebug("Dependency from the same library. ignored");
+ _D("Dependency from the same library. ignored");
continue;
}
void PluginInstallTask::stepResolvePluginDependencies()
{
- LogDebug("Plugin installation: step resolve dependencies ");
+ _D("Plugin installation: step resolve dependencies ");
//DISABLE_IF_PLUGIN_WITHOUT_LIB
if (m_pluginInfo.m_libraryName.empty()) {
//Installation completed
m_context->pluginHandle = m_pluginHandle;
m_context->installationCompleted = true;
- LogWarning("Plugin without library.");
+ _W("Plugin without library.");
return;
}
FOREACH(it, *(m_libraryObjects->getDependentObjects()))
{
if (m_libraryObjects->hasObject(*it)) {
- LogDebug("Dependency from the same library. ignored");
+ _D("Dependency from the same library. ignored");
continue;
}
handle = PluginDAO::getPluginHandleForImplementedObject(*it);
if (handle == INVALID_PLUGIN_HANDLE) {
- LogError("Library implementing: " << *it << " NOT FOUND");
+ _E("Library implementing: %s NOT FOUND", (*it).c_str());
PluginDAO::setPluginInstallationStatus(
m_pluginHandle,
PluginDAO::INSTALLATION_WAITING);
* @brief
*/
#include <string>
-#include <dpl/log/log.h>
+#include <installer_log.h>
#include "plugin_objects.h"
namespace {
std::string normalizeName(const std::string& objectName)
{
if (objectName.empty()) {
- LogError("Normalize name, name size is 0");
+ _E("Normalize name, name size is 0");
return objectName;
}
const std::string& parentName)
{
if (objectName.empty() || parentName.empty()) {
- LogError("Normalize name, name size or parent name size is 0");
+ _E("Normalize name, name size or parent name size is 0");
return std::string();
}
*/
#include <ace_registration.h>
-#include <dpl/log/log.h>
#include <dpl/foreach.h>
#include <ace_api_install.h>
+#include <installer_log.h>
+
namespace {
char* toAceString(const DPL::OptionalString& os)
{
const WrtDB::WidgetRegisterInfo& widgetConfig,
const WrtDB::WidgetCertificateDataList& certList)
{
- LogDebug("Updating Ace database");
+ _D("Updating Ace database");
struct widget_info wi;
switch (widgetConfig.webAppType.appType) {
wi.type = Tizen;
break;
default:
- LogError("Unknown application type");
+ _E("Unknown application type");
return false;
}
wi.version = toAceString(widgetConfig.configInfo.version);
wi.author = toAceString(widgetConfig.configInfo.authorName);
wi.shareHerf = strdup(widgetConfig.shareHref.c_str());
- LogDebug("Basic data converted. Certificates begin.");
+ _D("Basic data converted. Certificates begin.");
//one more element for NULL termination
- LogDebug("Found: " << certList.size() << " certificates");
+ _D("Found: %d certificates", certList.size());
ace_certificate_data** certData = new ace_certificate_data *
[certList.size() + 1];
certData[certList.size()] = NULL; // last element set to NULL
certData[i]->owner = DISTRIBUTOR;
break;
default:
- LogDebug("Unknown owner type of cert");
+ _D("Unknown owner type of cert");
certData[i]->owner = UNKNOWN;
break;
}
certData[i]->type = ROOT;
break;
default:
- LogError("Unknown type of cert");
+ _E("Unknown type of cert");
certData[i]->type = ENDENTITY;
break;
}
++i;
}
- LogDebug("Registerign widget in ace");
+ _D("Registerign widget in ace");
ace_return_t retval = ace_register_widget(
static_cast<ace_widget_handle_t>(widgetHandle), &wi, certData);
bool registerAceWidgetFromDB(const WrtDB::DbWidgetHandle& widgetHandle)
{
using namespace WrtDB;
- LogDebug("Updating Ace database from Widget DB");
+ _D("Updating Ace database from Widget DB");
struct widget_info wi;
DPL::OptionalString os;
WrtDB::WidgetCertificateDataList certList;
if (type == WrtDB::APP_TYPE_TIZENWEBAPP) {
wi.type = Tizen;
} else {
- LogError("Unknown application type");
+ _E("Unknown application type");
return false;
}
wi.version = toAceString(dao.getVersion());
wi.author = toAceString(dao.getAuthorName());
wi.shareHerf = strdup(dao.getShareHref().c_str());
- LogDebug("Basic data converted. Certificates begin.");
+ _D("Basic data converted. Certificates begin.");
certList = dao.getCertificateDataList();
}
Catch(WidgetDAOReadOnly::Exception::WidgetNotExist) {
- LogError("Widget does not exist");
+ _E("Widget does not exist");
return false;
}
//one more element for NULL termination
- LogDebug("Found: " << certList.size() << " certificates");
+ _D("Found: %d certificates", certList.size());
ace_certificate_data** certData = new ace_certificate_data *
[certList.size() + 1];
certData[certList.size()] = NULL; // last element set to NULL
certData[i]->owner = DISTRIBUTOR;
break;
default:
- LogDebug("Unknown owner type of cert");
+ _D("Unknown owner type of cert");
certData[i]->owner = UNKNOWN;
break;
}
certData[i]->type = ROOT;
break;
default:
- LogError("Unknown type of cert");
+ _E("Unknown type of cert");
certData[i]->type = ENDENTITY;
break;
}
++i;
}
- LogDebug("Registerign widget in ace");
+ _D("Registerign widget in ace");
ace_return_t retval = ace_register_widget(
static_cast<ace_widget_handle_t>(widgetHandle), &wi, certData);
#include <unistd.h>
#include <dirent.h>
#include <fstream>
-#include <dpl/log/log.h>
#include <dpl/foreach.h>
#include <dpl/utils/wrt_utility.h>
#include <widget_install_to_external.h>
#include <widget_install/widget_unzip.h>
+#include <installer_log.h>
+
using namespace WrtDB;
using namespace Jobs::Exceptions;
void JobWidgetInstall::appendNewInstallationTaskList()
{
- LogDebug("Configure installation succeeded");
+ _D("Configure installation succeeded");
m_installerContext.job->SetProgressFlag(true);
AddTask(new TaskRecovery(m_installerContext));
void JobWidgetInstall::appendUpdateInstallationTaskList()
{
- LogDebug("Configure installation updated");
- LogDebug("Widget Update");
+ _D("Configure installation updated");
+ _D("Widget Update");
m_installerContext.job->SetProgressFlag(true);
if (m_installerContext.mode.command ==
void JobWidgetInstall::appendFailureTaskList()
{
// Installation is not allowed to proceed due to widget update policy
- LogWarning("Configure installation failed!");
+ _W("Configure installation failed!");
GetInstallerStruct().pkgmgrInterface->sendSignal(
PKGMGR_START_KEY,
PKGMGR_START_INSTALL);
PKGMGR_PROGRESS_KEY,
percent.str());
- LogPedantic("Call widget install progressCallback");
+ _D("Call widget install progressCallback");
GetInstallerStruct().progressCallback(
GetInstallerStruct().userParam,
GetProgressPercent(),
PKGMGR_END_KEY,
PKGMGR_END_SUCCESS);
- LogDebug("Call widget install successfinishedCallback");
+ _D("Call widget install successfinishedCallback");
GetInstallerStruct().finishedCallback(GetInstallerStruct().userParam,
DPL::ToUTF8String(
tizenId), Jobs::Exceptions::Success);
// remove widget install information file
unlink(m_installerContext.installInfo.c_str());
- LogError("Error number: " << m_exceptionCaught);
- LogError("Message: " << m_exceptionMessage);
+ _E("Error number: %d", m_exceptionCaught);
+ _E("Message: %s", m_exceptionMessage.c_str());
TizenAppId & tizenId = m_installerContext.widgetConfig.tzAppid;
- LogDebug("Call widget install failure finishedCallback");
+ _D("Call widget install failure finishedCallback");
std::stringstream errorNum;
errorNum << m_exceptionCaught;
out << std::endl;
- LogDebug(out.str());
+ _D("%s", out.str().c_str());
}
} //namespace WidgetInstall
} //namespace Jobs
#include <widget_install/task_ace_check.h>
#include <dpl/assert.h>
-#include <dpl/log/log.h>
#include <dpl/foreach.h>
#include <widget_install/widget_install_context.h>
#include <dpl/wrt-dao-rw/widget_dao.h>
#include <ace_api_install.h>
+#include <installer_log.h>
+
namespace Jobs {
namespace WidgetInstall {
TaskAceCheck::TaskAceCheck(InstallerContext& context) :
void TaskAceCheck::StepAceCheck()
{
WrtDB::WidgetDAO dao(m_context.widgetConfig.tzAppid);
- LogDebug("StepAceCheck!");
+ _D("StepAceCheck!");
// This widget does not use any device cap
if (m_context.featureLogic->isDone()) {
return;
}
- LogDebug("StepAceCheck!");
+ _D("StepAceCheck!");
DPL::String deviceCap = m_context.featureLogic->getDevice();
- LogDebug("StepAceCheck!");
- LogDebug("DevCap is : " << deviceCap);
+ _D("StepAceCheck!");
+ _D("DevCap is : %ls", deviceCap.c_str());
std::string devCapStr = DPL::ToUTF8String(deviceCap);
ace_policy_result_t policyResult = ACE_DENY;
//TODO: remove dao.getHandle()
if (m_context.mode.installTime == InstallMode::InstallTime::PRELOAD) {
- LogDebug("This widget is preloaded. So ace check will be skiped");
+ _D("This widget is preloaded. So ace check will be skiped");
policyResult = ACE_PERMIT;
} else {
ace_return_t ret = ace_get_policy_result(
}
}
- LogDebug("PolicyResult is : " << static_cast<int>(policyResult));
+ _D("PolicyResult is : %d", static_cast<int>(policyResult));
m_context.staticPermittedDevCaps.insert(std::make_pair(deviceCap,
policyResult ==
ACE_PERMIT));
return;
}
- LogDebug("StepProcessAceResponse");
+ _D("StepProcessAceResponse");
m_context.featureLogic->next();
// No device caps left to process
if (m_context.featureLogic->isDone()) {
- LogDebug("All responses has been received from ACE.");
+ _D("All responses has been received from ACE.");
// Data to convert to C API
std::vector<std::string> devCaps;
std::vector<bool> devCapsSmack;
// Saving static dev cap permissions
FOREACH(cap, m_context.staticPermittedDevCaps) {
- LogDebug("staticPermittedDevCaps : " << cap->first
- << " smack: " << cap->second);
+ _D("staticPermittedDevCaps : %ls smack: %d", cap->first.c_str(), cap->second);
std::string devCapStr = DPL::ToUTF8String(cap->first);
devCaps.push_back(devCapStr);
devCapsSmack.push_back(cap->second);
for (std::set<std::string>::const_iterator iter = acceptedFeature.begin();
iter != acceptedFeature.end(); ++iter)
{
- LogDebug("Accepted feature item: " << iter->c_str());
+ _D("Accepted feature item: %s", iter->c_str());
featureList.items[i] = const_cast<char *>(iter->c_str());
i++;
}
delete[] featureList.items;
if (ACE_OK != ret) {
- LogError("Error in ace_set_feature");
+ _E("Error in ace_set_feature");
ThrowMsg(Exceptions::AceCheckFailed, "Instalation failure. "
"ace_set_feature failure.");
}
return;
}
- LogDebug("Next device cap.");
+ _D("Next device cap.");
// Process next device cap
SwitchToStep(&TaskAceCheck::StepAceCheck);
}
void TaskAceCheck::StepCheckAceResponse()
{
- LogDebug("Checking ACE response");
+ _D("Checking ACE response");
if (m_context.featureLogic->isRejected()) {
- LogError("Installation failure. Some devCap was not accepted by ACE.");
+ _E("Installation failure. Some devCap was not accepted by ACE.");
ThrowMsg(
Exceptions::PrivilegeLevelViolation,
"Instalation failure. "
"Some deviceCap was not accepted by ACE.");
}
- LogDebug("Updating \"feature reject status\" in database!");
+ _D("Updating \"feature reject status\" in database!");
auto it = m_context.featureLogic->resultBegin();
auto end = m_context.featureLogic->resultEnd();
for (; it != end; ++it) {
- LogDebug(
- " |- Feature: " << it->name << " has reject status: " <<
- it->rejected);
+ _D(" |- Feature: %ls has reject status: %d", it->name.c_str(), it->rejected);
if (it->rejected) {
WrtDB::WidgetDAO dao(m_context.widgetConfig.tzAppid);
dao.updateFeatureRejectStatus(*it);
}
}
- LogDebug("Installation continues...");
+ _D("Installation continues...");
}
void TaskAceCheck::StartStep()
{
- LogDebug("--------- <TaskAceCheck> : START ----------");
+ _D("--------- <TaskAceCheck> : START ----------");
}
void TaskAceCheck::EndStep()
InstallerContext::INSTALL_ACE_CHECK,
"Widget Access Control Check Finished");
- LogDebug("--------- <TaskAceCheck> : END ----------");
+ _D("--------- <TaskAceCheck> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
#include <widget_install/job_widget_install.h>
#include <widget_install/widget_install_errors.h>
#include <widget_install/widget_install_context.h>
-#include <dpl/log/log.h>
#include <dpl/wrt-dao-ro/global_config.h>
#include "wac_widget_id.h"
#include <ITapiModem.h>
#include <tapi_common.h>
+#include <installer_log.h>
+
using namespace ValidationCore;
using namespace WrtDB;
WidgetCertificateData result;
result.chainId = data.getSignatureNumber();
- LogDebug("result.chainId : " << result.chainId);
+ _D("result.chainId : %d", result.chainId);
result.owner = data.isAuthorSignature() ?
WidgetCertificateData::AUTHOR : WidgetCertificateData::DISTRIBUTOR;
{
ValidationCore::CertificateCollection chain;
if (false == chain.load(*it)) {
- LogError("Chain is broken");
+ _E("Chain is broken");
}
if (!chain.sort()) {
- LogError("Chain failed at sorting");
+ _E("Chain failed at sorting");
}
ValidationCore::CertificateList list = chain.getCertificateList();
void TaskCertify::processAuthorSignature(const SignatureData &data)
{
using namespace ValidationCore;
- LogDebug("DNS Identity match!");
+ _D("DNS Identity match!");
// this signature is verified or widget is distributor signed
m_contextData.widgetSecurity.setAuthorCertificatePtr(data.getEndEntityCertificatePtr());
CertificatePtr test = m_contextData.widgetSecurity.getAuthorCertificatePtr();
void TaskCertify::getSignatureFiles(std::string path, SignatureFileInfoSet& file)
{
- LogDebug("path : " << path);
+ _D("path : %s", path.c_str());
SignatureFileInfoSet signatureFiles;
SignatureFinder signatureFinder(path);
if (SignatureFinder::NO_ERROR != signatureFinder.find(file)) {
- LogError("Error in Signature Finder : " << path);
+ _E("Error in Signature Finder : %s", path.c_str());
ThrowMsg(Exceptions::SignatureNotFound,
"Error openig temporary widget directory");
}
void TaskCertify::stepSignature()
{
- LogDebug("================ Step: <<Signature>> ENTER ===============");
+ _D("================ Step: <<Signature>> ENTER ===============");
std::string widgetPath;
widgetPath = m_contextData.locations->getTemporaryPackageDir() + "/";
}
SignatureFileInfoSet::reverse_iterator iter = signatureFiles.rbegin();
- LogDebug("Number of signatures: " << signatureFiles.size());
+ _D("Number of signatures: %d", signatureFiles.size());
for (; iter != signatureFiles.rend(); ++iter) {
- LogDebug("Checking signature with id=" << iter->getFileNumber());
+ _D("Checking signature with id=%d", iter->getFileNumber());
SignatureData data(widgetPath + iter->getFileName(),
iter->getFileNumber());
}
if (result == WrtSignatureValidator::SIGNATURE_REVOKED) {
- LogWarning("Certificate is REVOKED");
+ _W("Certificate is REVOKED");
ThrowMsg(Exceptions::CertificateExpired,
"Certificate is REVOKED");
}
if (result == WrtSignatureValidator::SIGNATURE_INVALID &&
iter->getFileNumber() <= 1) {
- LogWarning("Signature is INVALID");
+ _W("Signature is INVALID");
// TODO change exception name
ThrowMsg(Exceptions::SignatureInvalid,
"Invalid Package");
}
}
} Catch(ParserSchemaException::Base) {
- LogError("Error occured in ParserSchema.");
+ _E("Error occured in ParserSchema.");
ReThrowMsg(Exceptions::SignatureInvalid,
"Error occured in ParserSchema.");
}
}
if (signatureFiles.empty()) {
- LogDebug("No signature files has been found.");
+ _D("No signature files has been found.");
}
- LogDebug("================ Step: <<Signature>> DONE ================");
+ _D("================ Step: <<Signature>> DONE ================");
m_contextData.job->UpdateProgress(
InstallerContext::INSTALL_DIGSIG_CHECK,
void TaskCertify::stepVerifyUpdate()
{
- LogDebug("Step: <<Check Update>>");
+ _D("Step: <<Check Update>>");
CertificatePtr newCertificate =
m_contextData.widgetSecurity.getAuthorCertificatePtr();
CertificatePtr oldCertificate =
if (!!newCertificate && !!oldCertificate) {
if (0 != newCertificate->getBase64().compare(oldCertificate->getBase64())) {
- LogDebug("old widget's author signer certificate : " <<
- oldCertificate->getBase64());
- LogDebug("new widget's author signer certificate : " <<
- newCertificate->getBase64());
+ _D("old widget's author signer certificate : %s", (oldCertificate->getBase64()).c_str());
+ _D("new widget's author signer certificate : %s", (newCertificate->getBase64()).c_str());
ThrowMsg(Exceptions::NotMatchedCertification,
"Author signer certificates doesn't match \
between old widget and installing widget");
void TaskCertify::StartStep()
{
- LogDebug("--------- <TaskCertify> : START ----------");
+ _D("--------- <TaskCertify> : START ----------");
}
void TaskCertify::EndStep()
{
- LogDebug("Step: <<CERTYFYING DONE>>");
+ _D("Step: <<CERTYFYING DONE>>");
m_contextData.job->UpdateProgress(
InstallerContext::INSTALL_CERT_CHECK,
"Widget Certification Check Finished");
- LogDebug("--------- <TaskCertify> : END ----------");
+ _D("--------- <TaskCertify> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
#include <widget_install/widget_install_errors.h>
#include <widget_install/widget_install_context.h>
#include <dpl/assert.h>
-#include <dpl/log/log.h>
#include <dpl/exception.h>
#include <dpl/string.h>
#include <dpl/foreach.h>
#include <dpl/utils/wrt_global_settings.h>
#include <dpl/wrt-dao-ro/global_dao_read_only.h>
+#include <installer_log.h>
+
using namespace ValidationCore;
using namespace WrtDB;
void TaskCertifyLevel::stepCertifyLevel()
{
- LogDebug("================ Step: <<Certify Level>> ENTER ===============");
+ _D("================ Step: <<Certify Level>> ENTER ===============");
if (!checkConfigurationLevel(getCertifyLevel())) {
ThrowMsg(Exceptions::PrivilegeLevelViolation, "setting level violate");
}
- LogDebug("================ Step: <<Certify Level>> DONE ================");
+ _D("================ Step: <<Certify Level>> DONE ================");
}
void TaskCertifyLevel::getSignatureFiles(const std::string& path,
SignatureFileInfoSet signatureFiles;
SignatureFinder signatureFinder(path);
if (SignatureFinder::NO_ERROR != signatureFinder.find(file)) {
- LogError("Error in Signature Finder : " << path);
+ _E("Error in Signature Finder : %s", path.c_str());
ThrowMsg(Exceptions::SignatureNotFound, "Signature not found");
}
}
}
SignatureFileInfoSet::reverse_iterator iter = signatureFiles.rbegin();
- LogDebug("Number of signatures: " << signatureFiles.size());
+ _D("Number of signatures: %d", signatureFiles.size());
Level level = Level::UNKNOWN;
for (; iter != signatureFiles.rend(); ++iter) {
- LogDebug("Checking signature with id=" << iter->getFileNumber());
+ _D("Checking signature with id=%d", iter->getFileNumber());
SignatureData data(widgetPath + iter->getFileName(),
iter->getFileNumber());
}
if (data.isAuthorSignature()) {
- LogDebug("Skip author signature");
+ _D("Skip author signature");
} else {
Level currentCertLevel =
certTypeToLevel(data.getVisibilityLevel());
}
if (currentCertLevel > level) {
level = currentCertLevel;
- LogDebug("level " << enumToString(level));
+ _D("level %s", enumToString(level).c_str());
}
}
} Catch(ParserSchemaException::Base) {
- LogError("Error occured in ParserSchema.");
+ _E("Error occured in ParserSchema.");
ReThrowMsg(Exceptions::SignatureInvalid,
"Error occured in ParserSchema.");
}
secureSettingIter ret = data.find(DPL::ToUTF8String(it->m_name));
if (ret != data.end()) {
if (level < ret->second) {
- LogError("\"" <<
- it->m_name <<
- "\" needs \"" <<
- enumToString(ret->second) <<
- "\" level");
+ _E("\"%ls\" needs \"%s\" level", it->m_name.c_str(), enumToString(ret->second).c_str());
return false;
}
}
it->m_disposition)
{
if (level < Level::PLATFORM) {
- LogError("\"tizen:disposition\" needs \"" <<
- enumToString(Level::PLATFORM) <<
- "\" level");
+ _E("\"tizen:disposition\" needs \"%s \" level", enumToString(Level::PLATFORM).c_str());
return false;
}
}
void TaskCertifyLevel::StartStep()
{
- LogDebug("--------- <TaskCertifyLevel> : START ----------");
+ _D("--------- <TaskCertifyLevel> : START ----------");
}
void TaskCertifyLevel::EndStep()
{
- LogDebug("--------- <TaskCertifyLevel> : END ----------");
+ _D("--------- <TaskCertifyLevel> : END ----------");
m_contextData.job->UpdateProgress(
InstallerContext::INSTALL_CERTIFY_LEVEL_CHECK,
#include <sys/stat.h>
#include <sys/time.h>
#include <dpl/wrt-dao-ro/global_config.h>
-#include <dpl/log/log.h>
#include <dpl/exception.h>
#include <dpl/errno_string.h>
#include <dpl/utils/wrt_utility.h>
#include <widget_install/widget_install_errors.h>
+#include <installer_log.h>
namespace Jobs {
namespace WidgetInstall {
std::string createTempPath(bool preload)
{
- LogDebug("Step: Creating temporary path");
+ _D("Step: Creating temporary path");
// Temporary path
std::ostringstream tempPathBuilder;
#include <widget_install/job_widget_install.h>
#include <widget_install/task_commons.h>
+#include <installer_log.h>
+
using namespace WrtDB;
namespace {
bool hasExtension(const std::string& filename, const std::string& extension)
{
- LogDebug("Looking for extension " << extension << " in: " << filename);
+ _D("Looking for extension %s in %s", extension.c_str(), filename.c_str());
size_t fileLen = filename.length();
size_t extLen = extension.length();
if (fileLen < extLen) {
- LogError("Filename " << filename << " is shorter than extension "
- << extension);
+ _E("Filename %s is shorter than extension %s", filename.c_str(), extension.c_str());
return false;
}
return (0 == filename.compare(fileLen - extLen, extLen, extension));
void TaskConfiguration::StartStep()
{
- LogDebug("--------- <TaskConfiguration> : START ----------");
+ _D("--------- <TaskConfiguration> : START ----------");
}
void TaskConfiguration::EndStep()
{
- LogDebug("--------- <TaskConfiguration> : END ----------");
+ _D("--------- <TaskConfiguration> : END ----------");
}
void TaskConfiguration::AppendTasklistStep()
m_context.confResult = m_result;
if (m_result == ConfigureResult::Ok) {
- LogInfo("TaskConfiguration -> new installation task list");
+ _D("TaskConfiguration -> new installation task list");
m_context.job->appendNewInstallationTaskList();
} else if (m_result == ConfigureResult::Updated) {
- LogInfo("TaskConfiguration -> update installation task list");
+ _D("TaskConfiguration -> update installation task list");
m_context.job->appendUpdateInstallationTaskList();
} else {
- LogInfo("TaskConfiguration -> failure task list");
+ _D("TaskConfiguration -> failure task list");
m_context.job->appendFailureTaskList();
}
}
wgtUnzip.unzipWgtFile(widgetPath, tempDir);
}
- LogDebug("widgetPath:" << widgetPath);
- LogDebug("tempPath:" << tempDir);
+ _D("widgetPath:%s", widgetPath.c_str());
+ _D("tempPath:%s", tempDir.c_str());
m_context.widgetConfig.packagingType =
checkPackageType(widgetPath, tempDir);
tempDir,
m_context.widgetConfig.packagingType,
m_context.mode.command == InstallMode::Command::REINSTALL);
- LogDebug("widget packaging type : " <<
- m_context.widgetConfig.packagingType.pkgType);
+ _D("widget packaging type : %d", m_context.widgetConfig.packagingType.pkgType);
setTizenId(configData);
setApplicationType(configData);
// TODO: (job_install_refactoring) hide this call
m_context.callerPkgId =
DPL::FromUTF8String(m_context.job->GetInstallerStruct().pkgmgrInterface->getCallerId());
- LogDebug("Caller Package Id : " << m_context.callerPkgId);
+ _D("Caller Package Id : %ls", m_context.callerPkgId.c_str());
// Configure installation
result = ConfigureInstallation(widgetPath, configData, tempDir);
}
Catch(Exceptions::OpenZipFailed)
{
- LogError("Failed to unzip for widget");
+ _E("Failed to unzip for widget");
result = ConfigureResult::Failed_OpenZipError;
}
Catch(Exceptions::ExtractFileFailed)
{
- LogError("Failed to unzip for widget");
+ _E("Failed to unzip for widget");
result = ConfigureResult::Failed_UnzipError;
}
Catch(Exceptions::DrmDecryptFailed)
{
- LogError("Failed to unzip for widget");
+ _E("Failed to unzip for widget");
result = ConfigureResult::Failed_DrmError;
}
Catch(Exceptions::MissingConfig)
{
- LogError("Failed to localize config.xml");
+ _E("Failed to localize config.xml");
result = ConfigureResult::Failed_InvalidConfig;
}
Catch(Exceptions::WidgetConfigFileInvalid)
{
- LogError("Invalid configuration file");
+ _E("Invalid configuration file");
result = ConfigureResult::Failed_InvalidConfig;
}
Catch(DPL::Exception)
{
- LogError("Unknown exception");
+ _E("Unknown exception");
result = ConfigureResult::Failed;
}
bool shouldMakeAppid = false;
using namespace PackageManager;
if (!!configInfo.tizenAppId) {
- LogDebug("Setting tizenAppId provided in config.xml: " <<
- configInfo.tizenAppId);
-
+ _D("Setting tizenAppId provided in config.xml: %ls", (*configInfo.tizenAppId).c_str());
m_context.widgetConfig.tzAppid = *configInfo.tizenAppId;
//check package id.
if (!!configInfo.tizenPkgId) {
- LogDebug("Setting tizenPkgId provided in config.xml: " <<
- configInfo.tizenPkgId);
-
+ _D("Setting tizenPkgId provided in config.xml: %ls", (*configInfo.tizenPkgId).c_str());
m_context.widgetConfig.tzPkgid = *configInfo.tizenPkgId;
} else {
DPL::String appid = *configInfo.tizenAppId;
} else {
shouldMakeAppid = true;
TizenPkgId pkgId = WidgetDAOReadOnly::generatePkgId();
- LogDebug("Checking if pkg id is unique");
+ _D("Checking if pkg id is unique");
while (true) {
if (!validateTizenPackageID(pkgId)) {
//path exist, chose another one
break;
}
m_context.widgetConfig.tzPkgid = pkgId;
- LogDebug("tizen_id name was generated by WRT: " <<
- m_context.widgetConfig.tzPkgid);
+ _D("tizen_id name was generated by WRT: %ls", m_context.widgetConfig.tzPkgid.c_str());
}
if (shouldMakeAppid == true) {
}
regex_t regx;
if (regcomp(®x, REG_NAME_PATTERN, REG_NOSUB | REG_EXTENDED) != 0) {
- LogDebug("Regcomp failed");
+ _D("Regcomp failed");
}
- LogDebug("Name : " << name);
+ _D("Name : %ls", (*name).c_str());
if (!name || (regexec(®x, DPL::ToUTF8String(*name).c_str(),
static_cast<size_t>(0), NULL, 0) != REG_NOERROR))
{
genName << "_" << allowedString[rand_r(&seed) % allowedString.length()];
name = DPL::FromUTF8String(genName.str());
- LogDebug("name was generated by WRT");
+ _D("name was generated by WRT");
}
regfree(®x);
- LogDebug("Name : " << name);
+ _D("Name : %ls", (*name).c_str());
std::ostringstream genid;
genid << m_context.widgetConfig.tzPkgid << "." << name;
- LogDebug("tizen appid was generated by WRT : " << genid.str());
+ _D("tizen appid was generated by WRT : %s", genid.str().c_str());
DPL::OptionalString appid = DPL::FromUTF8String(genid.str());
NormalizeAndTrimSpaceString(appid);
m_context.
widgetConfig.
tzPkgid));
- LogDebug("Tizen App Id : " << m_context.widgetConfig.tzAppid);
- LogDebug("Tizen Pkg Id : " << m_context.widgetConfig.tzPkgid);
- LogDebug("W3C Widget GUID : " << m_context.widgetConfig.guid);
+ _D("Tizen App Id : %ls", (m_context.widgetConfig.tzAppid).c_str());
+ _D("Tizen Pkg Id : %ls", (m_context.widgetConfig.tzPkgid).c_str());
+ _D("W3C Widget GUID : %ls", (*m_context.widgetConfig.guid).c_str());
+
}
void TaskConfiguration::configureWidgetLocation(const std::string & widgetPath,
m_context.locations->registerAppid(
DPL::ToUTF8String(m_context.widgetConfig.tzAppid));
- LogDebug("widgetSource " << widgetPath);
+ _D("widgetSource %s", widgetPath.c_str());
}
ConfigureResult TaskConfiguration::ConfigureInstallation(
if (!validateTizenApplicationID(
m_context.widgetConfig.tzAppid))
{
- LogError("tizen application ID is already used");
+ _E("tizen application ID is already used");
return ConfigureResult::Failed_InvalidConfig;
}
if (!validateTizenPackageID(m_context.widgetConfig.tzPkgid)) {
- LogError("tizen package ID is already used");
+ _E("tizen package ID is already used");
return ConfigureResult::Failed_AlreadyInstalled;
}
}
bool TaskConfiguration::validateTizenApplicationID(
const WrtDB::TizenAppId &tizenAppId)
{
- LogDebug("tizen application ID = [" << tizenAppId << "]");
+ _D("tizen application ID = [%ls]", tizenAppId.c_str());
regex_t reg;
if (regcomp(®, REG_TIZENID_PATTERN, REG_NOSUB | REG_EXTENDED) != 0) {
- LogDebug("Regcomp failed");
+ _D("Regcomp failed");
}
if (regexec(®, DPL::ToUTF8String(tizenAppId).c_str(), 0, NULL, 0)
return ConfigureResult::Failed;
}
- LogDebug("existing version = '" << update.existingVersion);
- LogDebug("incoming version = '" << update.incomingVersion);
- LogDebug("Tizen AppID = " << update.tzAppId);
+ _D("existing version = '%ls", update.existingVersion->Raw().c_str());
+ _D("incoming version = '%ls", update.incomingVersion->Raw().c_str());
+ _D("Tizen AppID = %ls", update.tzAppId.c_str());
// Check running state
bool isRunning = false;
app_manager_is_running(DPL::ToUTF8String(update.tzAppId).c_str(),
&isRunning);
if (APP_MANAGER_ERROR_NONE != ret) {
- LogError("Fail to get running state");
+ _E("Fail to get running state");
return ConfigureResult::Failed_WidgetRunning;
}
DPL::ToUTF8String(update.tzAppId).c_str(),
&appCtx);
if (APP_MANAGER_ERROR_NONE != ret) {
- LogError("Fail to get app_context");
+ _E("Fail to get app_context");
return ConfigureResult::Failed_WidgetRunning;
}
// terminate app_context_h
ret = app_manager_terminate_app(appCtx);
if (APP_MANAGER_ERROR_NONE != ret) {
- LogError("Fail to terminate running application");
+ _E("Fail to terminate running application");
app_context_destroy(appCtx);
return ConfigureResult::Failed_WidgetRunning;
} else {
DPL::ToUTF8String(update.tzAppId).c_str(),
&isStillRunning);
if (APP_MANAGER_ERROR_NONE != ret) {
- LogError("Fail to get running state");
+ _E("Fail to get running state");
return ConfigureResult::Failed_WidgetRunning;
}
if (!isStillRunning) {
}
}
if (isStillRunning) {
- LogError("Fail to terminate running application");
+ _E("Fail to terminate running application");
return ConfigureResult::Failed_WidgetRunning;
}
- LogDebug("terminate application");
+ _D("terminate application");
}
}
}
Catch(ElementParser::Exception::ParseError)
{
- LogError("Failed to parse config.xml file");
+ _E("Failed to parse config.xml file");
return ConfigParserData();
}
Catch(WidgetDAOReadOnly::Exception::WidgetNotExist)
{
- LogError("Failed to find installed widget - give proper tizenId");
+ _E("Failed to find installed widget - give proper tizenId");
return ConfigParserData();
}
Catch(Exceptions::WidgetConfigFileNotFound){
- LogError("Failed to find config.xml");
+ _E("Failed to find config.xml");
return ConfigParserData();
}
const ConfigParserData &configInfo,
const WrtDB::TizenAppId &tizenId)
{
- LogDebug("Checking up widget package for config.xml...");
+ _D("Checking up widget package for config.xml...");
OptionalWidgetVersion incomingVersion;
if (!configInfo.version.IsNull()) {
const std::string &tempPath)
{
if (hasExtension(widgetSource, XML_EXTENSION)) {
- LogDebug("Hosted app installation");
+ _D("Hosted app installation");
return PKG_TYPE_HOSTED_WEB_APP;
}
{
AppType widgetAppType = APP_TYPE_UNKNOWN;
FOREACH(iterator, configInfo.nameSpaces) {
- LogDebug("namespace = [" << *iterator << "]");
+ _D("namespace = [%ls]", (*iterator).c_str());
if (*iterator == ConfigurationNamespace::TizenWebAppNamespaceName) {
widgetAppType = APP_TYPE_TIZENWEBAPP;
m_context.widgetConfig.webAppType = widgetAppType;
- LogDebug("type = [" <<
- m_context.widgetConfig.webAppType.getApptypeToString() <<
- "]");
+ _D("type = [%s]", m_context.widgetConfig.webAppType.getApptypeToString().c_str());
}
bool TaskConfiguration::detectResourceEncryption(
if (it->m_name == SETTING_VALUE_ENCRYPTION &&
it->m_value == SETTING_VALUE_ENCRYPTION_ENABLE)
{
- LogDebug("resource need encryption");
+ _D("resource need encryption");
return true;
}
}
it->m_value ==
SETTING_VALUE_INSTALLTOEXT_PREPER_EXT)
{
- LogDebug("This widget will be installed to sd card");
+ _D("This widget will be installed to sd card");
m_context.locationType =
INSTALL_LOCATION_TYPE_EXTERNAL;
}
}
}
if (configValue != dbValue) {
- LogError("Not Support RDS mode because of encryption setting");
+ _E("Not Support RDS mode because of encryption setting");
return false;
}
}
#include <dpl/wrt-dao-rw/widget_dao.h>
#include <dpl/foreach.h>
#include <dpl/utils/wrt_utility.h>
-#include <dpl/log/log.h>
#include <dpl/assert.h>
#include <wrt-commons/security-origin-dao/security_origin_dao.h>
#include <wrt-commons/widget-interface-dao/widget_interface_dao.h>
#include <errno.h>
#include <string.h>
#include <map>
+#include <installer_log.h>
using namespace WrtDB;
time(&m_context.widgetConfig.installedTime);
if (m_context.isUpdateMode) { //update
- LogDebug("Registering widget... (update)");
+ _D("Registering widget... (update)");
Try
{
m_handleToRemove = WidgetDAOReadOnly::getHandle(
}
Catch(WidgetDAOReadOnly::Exception::WidgetNotExist)
{
- LogError(
- "Given tizenId not found for update installation (Same GUID?)");
+ _E("Given tizenId not found for update installation (Same GUID?)");
ThrowMsg(Exceptions::DatabaseFailure,
"Given tizenId not found for update installation");
}
m_handle =
WidgetDAOReadOnly::getHandle(m_context.widgetConfig.tzAppid);
} else { //new installation
- LogDebug("Registering widget...");
+ _D("Registering widget...");
WidgetDAO::registerWidget(
m_context.widgetConfig.tzAppid,
m_context.widgetConfig,
}
FOREACH(cap, m_context.staticPermittedDevCaps) {
- LogDebug(
- "staticPermittedDevCaps : " << cap->first
- << " smack status: " <<
- cap->second);
+ _D("staticPermittedDevCaps : %ls smack status: %d", cap->first.c_str(), cap->second);
}
- LogDebug("Widget registered");
+ _D("Widget registered");
}
Catch(WidgetDAO::Exception::DatabaseError)
{
- LogError("Database failure!");
+ _E("Database failure!");
ReThrowMsg(Exceptions::InsertNewWidgetFailed, "Database failure!");
}
Catch(DPL::DB::SqlConnection::Exception::Base)
{
- LogError("Database failure!");
+ _E("Database failure!");
ReThrowMsg(Exceptions::InsertNewWidgetFailed, "Database failure!");
}
}
void TaskDatabase::StepAceDBInsert()
{
- LogDebug("Inserting Ace database entry. New handle: " << m_handle);
+ _D("Inserting Ace database entry. New handle: %d", m_handle);
if (INVALID_WIDGET_HANDLE != m_handleToRemove) {
- LogDebug("Removing old insallation. Handle: " << m_handleToRemove);
+ _D("Removing old insallation. Handle: %d", m_handleToRemove);
if (ACE_OK != ace_unregister_widget(
static_cast<ace_widget_handle_t>(m_handleToRemove)))
{
- LogWarning(
- "Error while removing ace entry for previous insallation");
+ _W("Error while removing ace entry for previous insallation");
}
}
if (!AceApi::registerAceWidget(m_handle, m_context.widgetConfig,
m_context.widgetSecurity.getCertificateList()))
{
- LogError("ace database insert failed");
+ _E("ace database insert failed");
ThrowMsg(Exceptions::UpdateFailed,
"Update failure. ace_register_widget failed");
}
- LogDebug("Ace data inserted");
+ _D("Ace data inserted");
}
void TaskDatabase::StepSecurityOriginDBInsert()
{
- LogDebug("Create Security origin database");
+ _D("Create Security origin database");
// automatically create security origin database
using namespace SecurityOriginDB;
using namespace WrtDB;
void TaskDatabase::StepWidgetInterfaceDBInsert()
{
- LogDebug("Create Widget Interface database");
+ _D("Create Widget Interface database");
using namespace WidgetInterfaceDB;
using namespace WrtDB;
std::string dbPath = WidgetInterfaceDAO::databaseFileName(handle);
std::string backupDbPath = dbPath;
backupDbPath += GlobalConfig::GetBackupDatabaseSuffix();
- LogDebug("\"" << dbPath << "\" to \"" << backupDbPath << "\"");
+ _D("\"%s\" to \"%s\"", dbPath.c_str(), backupDbPath.c_str());
if (0 != std::rename(dbPath.c_str(), backupDbPath.c_str())) {
- LogError("widget interface database backup failed");
+ _E("widget interface database backup failed");
ThrowMsg(Exceptions::UpdateFailed,
"widget interface database backup failed");
}
}
Catch(WidgetInterfaceDAO::Exception::DatabaseError)
{
- LogError("widget interface database create failed");
+ _E("widget interface database create failed");
ThrowMsg(Exceptions::UpdateFailed,
"widget interface database create failed");
}
}
Catch(WidgetDAOReadOnly::Exception::WidgetNotExist)
{
- LogError(
- "Given tizenId not found for update installation (Same GUID?)");
+ _E("Given tizenId not found for update installation (Same GUID?)");
ThrowMsg(Exceptions::UpdateFailed,
"Given tizenId not found for update installation");
}
}
- LogDebug("Registering external files:");
+ _D("Registering external files:");
FOREACH(file, externalLocationsUpdate)
{
- LogDebug(" -> " << *file);
+ _D(" -> %s", (*file).c_str());
}
//set external locations to be registered
void TaskDatabase::StepRemoveExternalFiles()
{
if (!m_externalLocationsToRemove.empty()) {
- LogDebug("Removing external files:");
+ _D("Removing external files:");
}
FOREACH(file, m_externalLocationsToRemove)
{
if (WrtUtilFileExists(*file)) {
- LogDebug(" -> " << *file);
+ _D(" -> %s", (*file).c_str());
if (-1 == TEMP_FAILURE_RETRY(remove(file->c_str()))) {
ThrowMsg(Exceptions::RemovingFileFailure,
"Failed to remove external file");
}
} else if (WrtUtilDirExists(*file)) {
- LogDebug(" -> " << *file);
+ _D(" -> %s", (*file).c_str());
if (!WrtUtilRemove(*file)) {
ThrowMsg(Exceptions::RemovingFolderFailure,
"Failed to remove external directory");
}
} else {
- LogWarning(" -> " << *file << "(no such a path)");
+ _W(" -> %s(no such a path)", (*file).c_str());
}
}
}
void TaskDatabase::StepAbortDBInsert()
{
- LogWarning("[DB Update Task] Aborting... (DB Clean)");
+ _W("[DB Update Task] Aborting... (DB Clean)");
Try
{
if (m_context.isUpdateMode) {
} else {
WidgetDAO::unregisterWidget(m_context.widgetConfig.tzAppid);
}
- LogDebug("Cleaning DB successful!");
+ _D("Cleaning DB successful!");
}
Catch(DPL::DB::SqlConnection::Exception::Base)
{
- LogError("Failed to handle StepAbortDBClean!");
+ _E("Failed to handle StepAbortDBClean!");
}
}
void TaskDatabase::StepAbortAceDBInsert()
{
- LogWarning("[DB Update Task] ACE DB Aborting... (DB Clean)");
+ _W("[DB Update Task] ACE DB Aborting... (DB Clean)");
ace_unregister_widget(static_cast<ace_widget_handle_t>(m_handle));
// Remove also old one. If it was already updated nothing wrong will happen,
if (!AceApi::registerAceWidgetFromDB(m_handleToRemove))
{
- LogError("ace database restore failed");
+ _E("ace database restore failed");
}
- LogDebug("Ace data inserted");
+ _D("Ace data inserted");
}
void TaskDatabase::StepAbortWidgetInterfaceDBInsert()
{
- LogDebug("[DB Update Task] Widget interface Aborting...");
+ _D("[DB Update Task] Widget interface Aborting...");
using namespace WidgetInterfaceDB;
using namespace WrtDB;
// remove database
if (remove(dbPath.c_str()) != 0) {
- LogWarning("Fail to remove");
+ _W("Fail to remove");
}
// rollback database
if (m_context.isUpdateMode) {
std::string backupDbPath = dbPath;
backupDbPath += GlobalConfig::GetBackupDatabaseSuffix();
- LogDebug("\"" << dbPath << "\" to \"" << backupDbPath << "\"");
+ _D("\"%s\" to \"%s\"", dbPath.c_str(), backupDbPath.c_str());
if (0 != std::rename(backupDbPath.c_str(), dbPath.c_str())) {
- LogWarning("Fail to rollback");
+ _W("Fail to rollback");
}
}
}
} else {
boxType = DPL::ToUTF8String((**it).m_type);
}
- LogDebug("livebox id: " << boxId);
- LogDebug("livebox type: " << boxType);
+ _D("livebox id: %s", boxId.c_str());
+ _D("livebox type: %s", boxType.c_str());
int autoLaunch = (**it).m_autoLaunch == L"true" ? 1 : 0;
- LogDebug("livebox auto-launch: " << autoLaunch);
+ _D("livebox auto-launch: %d", autoLaunch);
int mouseEvent = (**it).m_boxInfo.m_boxMouseEvent == L"true" ? 1 : 0;
- LogDebug("livebox mouse-event: " << mouseEvent);
+ _D("livebox mouse-event: %d", mouseEvent);
int pdFastOpen = (**it).m_boxInfo.m_pdFastOpen == L"true" ? 1 : 0;
- LogDebug("livebox pd fast-open: " << pdFastOpen);
+ _D("livebox pd fast-open: %d", pdFastOpen);
web_provider_livebox_insert_box_info(
boxId.c_str(), tizenId.c_str(), boxType.c_str(),
void TaskDatabase::StartStep()
{
- LogDebug("--------- <TaskDatabase> : START ----------");
+ _D("--------- <TaskDatabase> : START ----------");
}
void TaskDatabase::EndStep()
{
- LogDebug("--------- <TaskDatabase> : END ----------");
+ _D("--------- <TaskDatabase> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
#include <memory>
-#include <dpl/log/log.h>
#include <dpl/errno_string.h>
#include <dpl/foreach.h>
#include <dpl/scoped_fclose.h>
#include <widget_install/widget_install_context.h>
#include <widget_install/widget_install_errors.h>
+#include <installer_log.h>
+
using namespace WrtDB;
namespace {
void TaskEncryptResource::StepEncryptResource()
{
- LogDebug("Step Encrypt resource");
+ _D("Step Encrypt resource");
EncryptDirectory(m_context.locations->getTemporaryRootDir());
}
if ((fts = fts_open(paths, FTS_PHYSICAL | FTS_NOCHDIR, NULL)) == NULL) {
//ERROR
int error = errno;
- LogWarning(__PRETTY_FUNCTION__ << ": fts_open failed with error: "
- << strerror(error));
+ _W("%s: fts_open failed with error: %s", __PRETTY_FUNCTION__, strerror(error));
ThrowMsg(Exceptions::EncryptionFailed, "Error reading directory: "
<< path);
}
case FTS_DNR:
case FTS_ERR:
default:
- LogWarning(__PRETTY_FUNCTION__
- << ": traversal failed on file: "
- << ftsent->fts_path
- << " with error: "
- << strerror(ftsent->fts_errno));
+ _W("%s: traversal failed on file: %s with error: %s", __PRETTY_FUNCTION__, ftsent->fts_path, strerror(ftsent->fts_errno));
ThrowMsg(Exceptions::EncryptionFailed, "Error reading file");
break;
}
if (fts_close(fts) == -1) {
int error = errno;
- LogWarning(__PRETTY_FUNCTION__ << ": fts_close failed with error: "
- << strerror(error));
+ _W("%s: fts_close failed with error: %s", __PRETTY_FUNCTION__, strerror(error));
}
}
void TaskEncryptResource::EncryptFile(const std::string &fileName)
{
- LogDebug("Encrypt file: " << fileName);
+ _D("Encrypt file: %s", fileName.c_str());
std::string encFile = fileName + ".enc";
struct stat info;
}
const std::size_t fileSize = info.st_size;
if (0 == fileSize) {
- LogDebug(fileName << " size is 0, so encryption is skiped");
+ _D("%s size is 0, so encryption is skiped", fileName.c_str());
return;
}
outFile.Reset();
inFile.Reset();
- LogDebug("File encrypted successfully");
- LogDebug("Remove plain-text file: " << fileName);
+ _D("File encrypted successfully");
+ _D("Remove plain-text file: %s", fileName.c_str());
if (0 != unlink(fileName.c_str()))
{
Throw(Exceptions::EncryptionFailed);
}
- LogDebug("Rename encrypted file");
+ _D("Rename encrypted file");
if (0 != std::rename(encFile.c_str(), fileName.c_str()))
{
Throw(Exceptions::EncryptionFailed);
void TaskEncryptResource::StartStep()
{
- LogDebug("--------- <TaskEncryptResource> : START ----------");
+ _D("--------- <TaskEncryptResource> : START ----------");
}
void TaskEncryptResource::EndStep()
InstallerContext::INSTALL_ECRYPTION_FILES,
"Ecrypt resource files");
- LogDebug("--------- <TaskEncryptResource> : END ----------");
+ _D("--------- <TaskEncryptResource> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
#include <widget_install/directory_api.h>
#include <dpl/utils/wrt_utility.h>
#include <dpl/foreach.h>
-#include <dpl/log/log.h>
#include <dpl/assert.h>
#include <dpl/errno_string.h>
#include <dpl/utils/folder_size.h>
#include <string>
#include <fstream>
#include <widget_install_to_external.h>
+#include <installer_log.h>
#define WEBAPP_DEFAULT_UID 5000
#define WEBAPP_DEFAULT_GID 5000
void changeOwnerForDirectory(std::string storagePath, mode_t mode) {
if (euidaccess(storagePath.c_str(), F_OK) != 0) {
if (!WrtUtilMakeDir(storagePath, mode)) {
- LogError("Failed to create directory : " << storagePath);
+ _E("Failed to create directory : %s", storagePath.c_str());
ThrowMsg(Jobs::WidgetInstall::Exceptions::FileOperationFailed,
"Failed to create directory : " << storagePath);
}
"Chown to invaild user");
}
} else if (euidaccess(storagePath.c_str(), W_OK | R_OK | X_OK) == 0) {
- LogDebug(storagePath << " already exists.");
+ _D("%s already exists.", storagePath.c_str());
// Even if private directory already is created, private dircetory
// should change owner.
if (chown(storagePath.c_str(),
// If package type is widget with osp service, we don't need to make bin
// and src directory
if (m_context.widgetConfig.packagingType == PKG_TYPE_HYBRID_WEB_APP) {
- LogDebug("Doesn't need to create resource directory");
+ _D("Doesn't need to create resource directory");
} else {
- LogDebug("Create resource directory");
+ _D("Create resource directory");
WrtUtilMakeDir(widgetBinPath);
WrtUtilMakeDir(widgetSrcPath);
if (m_context.mode.installTime == InstallMode::InstallTime::PRELOAD) {
void TaskFileManipulation::StepCreatePrivateStorageDir()
{
std::string storagePath = m_context.locations->getPrivateStorageDir();
- LogDebug("Create private storage directory : " <<
- m_context.locations->getPrivateStorageDir());
+ _D("Create private storage directory : %s", m_context.locations->getPrivateStorageDir().c_str());
changeOwnerForDirectory(storagePath, PRIVATE_STORAGE_MODE);
if (m_context.isUpdateMode) { //update
std::string backData = m_context.locations->getBackupPrivateDir();
- LogDebug("copy private storage " << backData << " to " << storagePath);
+ _D("copy private storage %s to %s", backData.c_str(), storagePath.c_str());
if (!DirectoryApi::DirectoryCopy(backData, storagePath)) {
- LogError("Failed to rename " << backData << " to " << storagePath);
+ _E("Failed to rename %s to %s", backData.c_str(), storagePath.c_str());
ThrowMsg(Exceptions::BackupFailed,
"Error occurs copy private strage files");
}
}
std::string tempStoragePath = m_context.locations->getPrivateTempStorageDir();
- LogDebug("Create temp private storage directory : " << tempStoragePath);
+ _D("Create temp private storage directory : %s", tempStoragePath.c_str());
changeOwnerForDirectory(tempStoragePath, PRIVATE_STORAGE_MODE);
}
instDir = m_context.locations->getSourceDir();
}
- LogDebug("Copy file from temp directory to " << instDir);
+ _D("Copy file from temp directory to %s", instDir.c_str());
if (!WrtUtilRemove(instDir)) {
ThrowMsg(Exceptions::RemovingFolderFailure,
"Error occurs during removing existing folder");
WrtDB::GlobalConfig::GetWidgetResPath();
if (0 != access(optRes.c_str(), F_OK)) {
- LogDebug("Make symbolic name for preload app" <<
- usrRes << " to " << optRes);
+ _D("Make symbolic name for preload app %s to %s", usrRes.c_str(), optRes.c_str());
if (symlink(usrRes.c_str(), optRes.c_str()) != 0)
{
int error = errno;
if (error)
- LogPedantic("Failed to make a symbolic name for a file "
- << "[" << DPL::GetErrnoString(error) << "]");
+ _E("Failed to make a symbolic name for a file [%s]", (DPL::GetErrnoString(error)).c_str());
ThrowMsg(Exceptions::FileOperationFailed,
"Symbolic link creating is not done.");
}
std::string dataDir = m_context.locations->getPackageInstallationDir() +
"/" + WrtDB::GlobalConfig::GetWidgetPrivateStoragePath();
if (0 != access(dataDir.c_str(), F_OK)) {
- LogDebug("Make symbolic name for preload app " <<
- storagePath << " to " << dataDir);
+ _D("Make symbolic name for preload app %s to %s", storagePath.c_str(), dataDir.c_str());
if (symlink(storagePath.c_str(), dataDir.c_str()) != 0)
{
int error = errno;
if (error)
- LogPedantic("Failed to make a symbolic name for a file "
- << "[" << DPL::GetErrnoString(error) << "]");
+ _E("Failed to make a symbolic name for a file [%s]", (DPL::GetErrnoString(error)).c_str());
ThrowMsg(Exceptions::FileOperationFailed,
"Symbolic link creating is not done.");
}
if (m_context.widgetConfig.packagingType != PKG_TYPE_HYBRID_WEB_APP) {
std::string widgetBinPath = m_context.locations->getBinaryDir();
std::string userBinPath = m_context.locations->getUserBinaryDir();
- LogDebug("Make symbolic link for preload app " << widgetBinPath <<
- " to " << userBinPath);
+ _D("Make symbolic link for preload app %s to %s", widgetBinPath.c_str(), userBinPath.c_str());
if (symlink(widgetBinPath.c_str(), userBinPath.c_str()) != 0)
{
int error = errno;
if (error)
- LogPedantic("Failed to make a symbolic name for a file "
- << "[" << DPL::GetErrnoString(error) << "]");
+ _E("Failed to make a symbolic name for a file [%s]", (DPL::GetErrnoString(error)).c_str());
ThrowMsg(Exceptions::FileOperationFailed,
"Symbolic link creating is not done.");
}
void TaskFileManipulation::StepAbortRenamePath()
{
- LogDebug("[Rename Widget Path] Aborting.... (Rename path)");
+ _D("[Rename Widget Path] Aborting.... (Rename path)");
std::string widgetPath;
widgetPath = m_context.locations->getPackageInstallationDir();
if (!WrtUtilRemove(widgetPath)) {
- LogError("Error occurs during removing existing folder");
+ _E("Error occurs during removing existing folder");
}
// Remove user data directory if preload web app.
std::string userData = m_context.locations->getUserDataRootDir();
if (0 == access(userData.c_str(), F_OK)) {
if (!WrtUtilRemove(userData)) {
- LogError("Error occurs during removing user data directory");
+ _E("Error occurs during removing user data directory");
}
}
- LogDebug("Rename widget path sucessful!");
+ _D("Rename widget path sucessful!");
}
void TaskFileManipulation::StepPrepareExternalDir()
{
- LogDebug("Step prepare to install in exernal directory");
+ _D("Step prepare to install in exernal directory");
Try {
std::string pkgid =
DPL::ToUTF8String(m_context.widgetConfig.tzPkgid);
void TaskFileManipulation::StepInstallToExternal()
{
- LogDebug("StepInstallExternal");
+ _D("StepInstallExternal");
if (!WrtUtilMakeDir(m_context.locations->getSourceDir())) {
ThrowMsg(Exceptions::ErrorExternalInstallingFailure,
"To make src \
directory failed");
}
- LogDebug("Resource move to external storage " <<
- m_context.locations->getSourceDir());
+ _D("Resource move to external storage %s", m_context.locations->getSourceDir().c_str());
if (!_FolderCopy(m_context.locations->getTemporaryPackageDir(),
m_context.locations->getSourceDir()))
{
void TaskFileManipulation::StepAbortCreateExternalDir()
{
- LogError("Abort StepAbortCreateExternalDir");
+ _E("Abort StepAbortCreateExternalDir");
if (m_context.isUpdateMode) {
WidgetInstallToExtSingleton::Instance().postUpgrade(false);
} else {
void TaskFileManipulation::StepCreateSharedFolder()
{
- LogDebug("StepCreateSharedFolder");
+ _D("StepCreateSharedFolder");
std::string sharedPath = m_context.locations->getSharedRootDir();
- LogDebug("Create shared directory : " <<
- m_context.locations->getSharedRootDir());
+ _D("Create shared directory : %s", m_context.locations->getSharedRootDir().c_str());
WrtUtilMakeDir(sharedPath);
WrtUtilMakeDir(m_context.locations->getSharedResourceDir());
&& m_context.mode.installTime == InstallMode::InstallTime::PRELOAD)) {
/* Restore /shared/data */
- LogDebug("copy " << m_context.locations->getBackupSharedDataDir() <<
- " to " << m_context.locations->getSharedDataDir());
+ _D("copy %s to %s", m_context.locations->getBackupSharedDataDir().c_str(), m_context.locations->getSharedDataDir().c_str());
if (!DirectoryApi::DirectoryCopy(
m_context.locations->getBackupSharedDataDir(),
m_context.locations->getSharedDataDir())) {
- LogError("Failed to rename " <<
- m_context.locations->getBackupSharedDataDir() <<
- " to " << m_context.locations->getSharedDataDir());
+ _E("Failed to rename %s to %s", m_context.locations->getBackupSharedDataDir().c_str(), m_context.locations->getSharedDataDir().c_str());
ThrowMsg(Exceptions::BackupFailed,
"Error occurs copy shared strage files");
}
/* Restore /shared/trusted */
- LogDebug("copy " << m_context.locations->getBackupSharedTrustedDir() <<
- " to " << m_context.locations->getSharedTrustedDir());
+ _D("copy %s to %s", m_context.locations->getBackupSharedTrustedDir().c_str(), m_context.locations->getSharedTrustedDir().c_str());
if (!DirectoryApi::DirectoryCopy(
m_context.locations->getBackupSharedTrustedDir(),
m_context.locations->getSharedTrustedDir())) {
- LogError("Failed to rename " <<
- m_context.locations->getBackupSharedTrustedDir() << " to " <<
- m_context.locations->getSharedTrustedDir());
+ _E("Failed to rename %s to %s", m_context.locations->getBackupSharedTrustedDir().c_str(), m_context.locations->getSharedTrustedDir().c_str());
ThrowMsg(Exceptions::BackupFailed,
"Error occurs copy shared strage files");
}
void TaskFileManipulation::StartStep()
{
- LogDebug("--------- <TaskFileManipulation> : START ----------");
+ _D("--------- <TaskFileManipulation> : START ----------");
}
void TaskFileManipulation::EndStep()
{
- LogDebug("--------- <TaskFileManipulation> : END ----------");
+ _D("--------- <TaskFileManipulation> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
#include <pkgmgr/pkgmgr_parser.h>
#include <pkgmgr-info.h>
#include <fstream>
-#include <dpl/log/log.h>
#include <dpl/errno_string.h>
#include <dpl/foreach.h>
#include <dpl/wrt-dao-ro/global_config.h>
#include <widget_install/widget_install_context.h>
#include <widget_install/widget_install_errors.h>
+#include <installer_log.h>
+
using namespace WrtDB;
namespace {
void TaskInstallOspsvc::StepInstallOspService()
{
- LogDebug("Step: installation for osp service");
+ _D("Step: installation for osp service");
std::ostringstream commStr;
commStr << OSP_INSTALL_STR << BashUtils::escape_arg(
m_context.locations->getPackageInstallationDir());
//commStr << " 2>&1";
- LogDebug("osp install command : " << commStr.str());
+ _D("osp install command : %s", commStr.str().c_str());
char readBuf[MAX_BUF_SIZE];
FILE *fd;
fd = popen(commStr.str().c_str(), "r");
if (NULL == fd) {
- LogError("Failed to installtion osp service");
+ _E("Failed to installtion osp service");
ThrowMsg(Exceptions::InstallOspsvcFailed,
"Error occurs during\
install osp service");
if (fgets(readBuf, MAX_BUF_SIZE, fd) == NULL)
{
- LogError("Failed to installtion osp service.\
+ _E("Failed to installtion osp service.\
Inability of reading file.");
ThrowMsg(Exceptions::InstallOspsvcFailed,
"Error occurs during\
install osp service");
}
- LogDebug("return value : " << readBuf);
+ _D("return value : %s", readBuf);
int result = atoi(readBuf);
if (0 != result) {
void TaskInstallOspsvc::StartStep()
{
- LogDebug("--------- <TaskInstallOspsvc> : START ----------");
+ _D("--------- <TaskInstallOspsvc> : START ----------");
}
void TaskInstallOspsvc::EndStep()
InstallerContext::INSTALL_INSTALL_OSPSVC,
"Installed Osp servcie");
- LogDebug("--------- <TaskInstallOspsvc> : END ----------");
+ _D("--------- <TaskInstallOspsvc> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
#include <web_provider_plugin_info.h>
#include <dpl/wrt-dao-ro/global_config.h>
#include <dpl/wrt-dao-ro/config_parser_data.h>
-#include <dpl/log/log.h>
#include <dpl/file_input.h>
#include <dpl/errno_string.h>
#include <dpl/file_output.h>
#include <dpl/localization/LanguageTagsProvider.h>
#include <dpl/utils/path.h>
+#include <installer_log.h>
+
#define DEFAULT_ICON_NAME "icon.png"
#define DEFAULT_PREVIEW_NAME "preview.png"
DPL::String langTag = tag;
- LogDebug("Trying to map language tag: " << langTag);
+ _D("Trying to map language tag: %ls", langTag.c_str());
size_t pos = langTag.find_first_of(L'_');
if (pos != DPL::String::npos) {
langTag.erase(pos);
LanguageTagMap::iterator it = TagsMap.find(langTag);
if (it != TagsMap.end()) {
ret = it->second;
+ _D("Mapping IANA Language tag to language tag: %ls -> %ls", langTag.c_str(), (*ret).c_str());
}
- LogDebug("Mapping IANA Language tag to language tag: " <<
- langTag << " -> " << ret);
return ret;
}
{
int error = errno;
if (error)
- LogPedantic("Failed to make a symbolic name for a file "
- << "[" << DPL::GetErrnoString(error) << "]");
+ _E("Failed to make a symbolic name for a file [%s]", DPL::GetErrnoString(error).c_str());
}
// app-control widgets
if (symlink(clientExeStr.c_str(), controlExec.c_str()) != 0) {
int error = errno;
if (error) {
- LogPedantic("Failed to make a symbolic name for a file "
- << "[" << DPL::GetErrnoString(error) << "]");
+ _E("Failed to make a symbolic name for a file [%s]", DPL::GetErrnoString(error).c_str());
}
}
}
#else
//default widget
- LogDebug("link -s " << clientExeStr << " " << exec);
+ _D("link -s %s %s", clientExeStr.c_str(), exec.c_str());
errno = 0;
if (symlink(clientExeStr.c_str(), exec.c_str()) != 0)
{
int error = errno;
if (error)
- LogPedantic("Failed to make a symbolic name for a file "
- << "[" << DPL::GetErrnoString(error) << "]");
+ _E("Failed to make a symbolic name for a file [%s]", DPL::GetErrnoString(error).c_str());
}
#endif
if (symlink(boxExec.c_str(), boxSymlink.c_str()) != 0) {
if (errno) {
- LogPedantic("Failed to make a symbolic name for a file "
- << "[" << DPL::GetErrnoString(errno) << "]");
+ _E("Failed to make a symbolic name for a file [%s]", DPL::GetErrnoString(errno).c_str());
}
}
}
void TaskManifestFile::stepCopyIconFiles()
{
- LogDebug("CopyIconFiles");
+ _D("CopyIconFiles");
//This function copies icon to desktop icon path. For each locale avaliable
//which there is at least one icon in widget for, icon file is copied.
DPL::String src = icon->src;
FOREACH(locale, icon->availableLocales)
{
- LogDebug("Icon for locale: " << *locale << "is: " << src);
+ _D("Icon for locale: %ls is: %ls", (*locale).c_str(), src.c_str());
if (std::find(generatedLocales.begin(), generatedLocales.end(),
*locale) != generatedLocales.end())
{
- LogDebug("Skipping - has that locale");
+ _D("Skipping - has that locale");
continue;
} else {
generatedLocales.push_back(*locale);
targetFile.Fullpath());
}
- LogDebug("Copying icon: " << sourceFile << " -> " << targetFile);
+ _D("Copying icon: %s -> %s", sourceFile.Filename().c_str(), targetFile.Filename().c_str());
icon_list.push_back(targetFile.Fullpath());
// Error while opening or closing source file
//ReThrowMsg(InstallerException::CopyIconFailed,
// sourceFile.str());
- LogError(
- "Copying widget's icon failed. Widget's icon will not be" \
+ _E("Copying widget's icon failed. Widget's icon will not be" \
"available from Main Screen");
}
// Error while opening or closing target file
//ReThrowMsg(InstallerException::CopyIconFailed,
// targetFile.str());
- LogError(
- "Copying widget's icon failed. Widget's icon will not be" \
+ _E("Copying widget's icon failed. Widget's icon will not be" \
"available from Main Screen");
}
// Error while copying
//ReThrowMsg(InstallerException::CopyIconFailed,
// targetFile.str());
- LogError(
- "Copying widget's icon failed. Widget's icon will not be" \
+ _E("Copying widget's icon failed. Widget's icon will not be" \
"available from Main Screen");
}
}
void TaskManifestFile::stepCopyLiveboxFiles()
{
- LogDebug("Copy Livebox Files");
+ _D("Copy Livebox Files");
using namespace WrtDB;
ConfigParserData &data = m_context.widgetConfig.configInfo;
}
Catch(DPL::Exception)
{
- LogError("Copying Dynamic Box File Failed. " << sourceFile
- << " to " << targetFile);
+ _E("Copying Dynamic Box File Failed. %s to %s", sourceFile.c_str(), targetFile.c_str());
ReThrowMsg(Exceptions::DynamicBoxFailed, "Dynamic Box File Copy Failed.");
}
}
Try
{
if (isAdded) {
- LogDebug("UiApplication for d-box is already added");
+ _D("UiApplication for d-box is already added");
return false;
}
uiApp.setNodisplay(true);
}
Catch(DPL::Exception)
{
- LogError("Adding UiApplication on xml is failed.");
+ _E("Adding UiApplication on xml is failed.");
isAdded = false;
return false;
}
void TaskManifestFile::stepBackupIconFiles()
{
- LogDebug("Backup Icon Files");
+ _D("Backup Icon Files");
backup_dir << m_context.locations->getBackupDir() << "/";
void TaskManifestFile::stepAbortIconFiles()
{
- LogDebug("Abrot Icon Files");
+ _D("Abrot Icon Files");
FOREACH(it, icon_list)
{
- LogDebug("Remove Update Icon : " << (*it));
+ _D("Remove Update Icon : %s", (*it).c_str());
unlink((*it).c_str());
}
}
Catch(DPL::FileInput::Exception::Base)
{
- LogError("Restoration icon File Failed." << backup_file.str()
- << " to " << res_file.str());
+ _E("Restoration icon File Failed. %s to %s", backup_file.str().c_str(), res_file.str().c_str());
}
Catch(DPL::FileOutput::Exception::Base)
{
- LogError("Restoration icon File Failed." << backup_file.str()
- << " to " << res_file.str());
+ _E("Restoration icon File Failed. %s to %s", backup_file.str().c_str(), res_file.str().c_str());
}
Catch(DPL::CopyFailed)
{
- LogError("Restoration icon File Failed." << backup_file.str()
- << " to " << res_file.str());
+ _E("Restoration icon File Failed. %s to %s", backup_file.str().c_str(), res_file.str().c_str());
}
}
}
void TaskManifestFile::backupIconFiles()
{
- LogDebug("Backup Icon Files");
+ _D("Backup Icon Files");
std::ostringstream b_icon_dir;
b_icon_dir << backup_dir.str() << "icons";
- LogDebug("Create icon backup folder : " << b_icon_dir.str());
+ _D("Create icon backup folder : %s", b_icon_dir.str().c_str());
WrtUtilMakeDir(b_icon_dir.str());
std::list<std::string> fileList;
backup_icon << b_icon_dir.str() << "/" << (*it);
- LogDebug("Backup icon file " << icon_file.str() << " to " <<
- backup_icon.str());
+ _D("Backup icon file %s to %s", icon_file.str().c_str(), backup_icon.str().c_str());
Try
{
DPL::FileInput input(icon_file.str());
}
Catch(DPL::FileInput::Exception::Base)
{
- LogError("Backup Desktop File Failed.");
+ _E("Backup Desktop File Failed.");
ReThrowMsg(Exceptions::BackupFailed, icon_file.str());
}
Catch(DPL::FileOutput::Exception::Base)
{
- LogError("Backup Desktop File Failed.");
+ _E("Backup Desktop File Failed.");
ReThrowMsg(Exceptions::BackupFailed, backup_icon.str());
}
Catch(DPL::CopyFailed)
{
- LogError("Backup Desktop File Failed.");
+ _E("Backup Desktop File Failed.");
ReThrowMsg(Exceptions::BackupFailed, backup_icon.str());
}
unlink((*it).c_str());
{
DIR* dir = opendir(path);
if (!dir) {
- LogError("icon directory doesn't exist");
+ _E("icon directory doesn't exist");
ThrowMsg(Exceptions::FileOperationFailed, path);
}
}
if (return_code != 0 || errno != 0) {
- LogError("readdir_r() failed with " << DPL::GetErrnoString());
+ _E("readdir_r() failed with %s", DPL::GetErrnoString().c_str());
}
if (-1 == TEMP_FAILURE_RETRY(closedir(dir))) {
- LogError("Failed to close dir: " << path << " with error: "
- << DPL::GetErrnoString());
+ _E("Failed to close dir: %s with error: %s", path, DPL::GetErrnoString().c_str());
}
}
destFile << DPL::ToUTF8String(manifest_name);
commit_manifest = destFile.str();
- LogDebug("Commiting manifest file : " << commit_manifest);
+ _D("Commiting manifest file : %s", commit_manifest.c_str());
commitManifest();
if (!(m_context.mode.rootPath == InstallMode::RootPath::RO &&
m_context.mode.installTime == InstallMode::InstallTime::PRELOAD
&& m_context.mode.extension == InstallMode::ExtensionType::DIR)) {
- LogDebug("cp " << manifest_file << " " << commit_manifest);
+ _D("cp %ls %s", manifest_file.c_str(), commit_manifest.c_str());
DPL::FileInput input(DPL::ToUTF8String(manifest_file));
DPL::FileOutput output(commit_manifest);
DPL::Copy(&input, &output);
- LogDebug("Manifest writen to: " << commit_manifest);
+ _D("Manifest writen to: %s", commit_manifest.c_str());
//removing temp file
unlink((DPL::ToUTF8String(manifest_file)).c_str());
void TaskManifestFile::writeManifest(const DPL::String & path)
{
- LogDebug("Generating manifest file : " << path);
+ _D("Generating manifest file : %ls", path.c_str());
Manifest manifest;
UiApplication uiApp;
#endif
manifest.generate(path);
- LogDebug("Manifest file serialized");
+ _D("Manifest file serialized");
}
void TaskManifestFile::setWidgetExecPath(UiApplication & uiApp,
if (!postfix.empty()) {
exec.append(postfix);
}
- LogDebug("exec = " << exec);
+ _D("exec = %s", exec.c_str());
uiApp.setExec(DPL::FromASCIIString(exec));
}
if (std::find(generatedLocales.begin(), generatedLocales.end(),
*locale) != generatedLocales.end())
{
- LogDebug("Skipping - has that locale - already in manifest");
+ _D("Skipping - has that locale - already in manifest");
continue;
} else {
generatedLocales.push_back(*locale);
m_context.widgetConfig.configInfo.appControlList;
if (appControlList.empty()) {
- LogDebug("Widget doesn't contain app control");
+ _D("Widget doesn't contain app control");
return;
}
m_context.widgetConfig.configInfo.categoryList;
if (categoryList.empty()) {
- LogDebug("Widget doesn't contain application category");
+ _D("Widget doesn't contain application category");
return;
}
FOREACH(it, categoryList) {
m_context.widgetConfig.configInfo.metadataList;
if (metadataList.empty()) {
- LogDebug("Web application doesn't contain metadata");
+ _D("Web application doesn't contain metadata");
return;
}
FOREACH(it, metadataList) {
m_context.widgetConfig.configInfo.m_livebox;
if (liveboxList.empty()) {
- LogDebug("no livebox");
+ _D("no livebox");
return;
}
if (!addBoxUiApplication(manifest)) {
- LogDebug("error during adding UiApplication for d-box");
+ _D("error during adding UiApplication for d-box");
return;
}
FOREACH(it, liveboxList) {
- LogDebug("setLiveBoxInfo");
+ _D("setLiveBoxInfo");
LiveBoxInfo liveBox;
DPL::Optional<WrtDB::ConfigParserData::LiveboxInfo> ConfigInfo = *it;
DPL::String appid = m_context.widgetConfig.tzAppid;
if (ConfigInfo->m_boxInfo.m_boxSrc.empty() ||
ConfigInfo->m_boxInfo.m_boxSize.empty())
{
- LogDebug("Widget doesn't contain box");
+ _D("Widget doesn't contain box");
return;
} else {
BoxInfoType box;
AccountProviderType provider;
if (account.m_iconSet.empty()) {
- LogDebug("Widget doesn't contain Account");
+ _D("Widget doesn't contain Account");
return;
}
if (account.m_multiAccountSupport) {
#include <string>
#include <fstream>
-#include <dpl/log/log.h>
#include <dpl/wrt-dao-ro/global_config.h>
#include <dpl/foreach.h>
#include <dpl/sstream.h>
#include <widget_install/widget_install_context.h>
#include <widget_install/widget_install_errors.h>
+#include <installer_log.h>
+
using namespace WrtDB;
namespace {
m_manifest += "/opt/share/packages/";
}
m_manifest += DPL::ToUTF8String(m_context.widgetConfig.tzPkgid) + ".xml";
- LogDebug("manifest file : " << m_manifest);
+ _D("manifest file : %s", m_manifest.c_str());
if (m_context.isUpdateMode || (
m_context.mode.rootPath == InstallMode::RootPath::RO
m_manifest.c_str(), (updateTags[0] == NULL) ? NULL : updateTags);
if (code != 0) {
- LogError("Manifest parser error: " << code);
+ _E("Manifest parser error: %d", code);
ThrowMsg(Exceptions::ManifestInvalid, "Parser returncode: " << code);
}
} else {
m_manifest.c_str(), (updateTags[0] == NULL) ? NULL : updateTags);
if (code != 0) {
- LogError("Manifest parser error: " << code);
+ _E("Manifest parser error: %d", code);
ThrowMsg(Exceptions::ManifestInvalid, "Parser returncode: " << code);
}
}
m_context.job->UpdateProgress(
InstallerContext::INSTALL_PKGINFO_UPDATE,
"Manifest Update Finished");
- LogDebug("Manifest parsed");
+ _D("Manifest parsed");
}
void TaskPkgInfoUpdate::StepSetCertiInfo()
{
- LogDebug("StepSetCertiInfo");
+ _D("StepSetCertiInfo");
if (pkgmgr_installer_create_certinfo_set_handle(&m_pkgHandle) < 0) {
- LogError("pkgmgrInstallerCreateCertinfoSetHandle fail");
+ _E("pkgmgrInstallerCreateCertinfoSetHandle fail");
ThrowMsg(Exceptions::SetCertificateInfoFailed,
"Failed to create certificate handle");
}
m_context.widgetConfig.tzPkgid).c_str()),
m_pkgHandle)) < 0)
{
- LogError("pkgmgrInstallerSaveCertinfo fail");
+ _E("pkgmgrInstallerSaveCertinfo fail");
ThrowMsg(Exceptions::SetCertificateInfoFailed,
"Failed to Installer Save Certinfo");
} else {
- LogDebug("Succeed to save Certinfo");
+ _D("Succeed to save Certinfo");
}
if (pkgmgr_installer_destroy_certinfo_set_handle(m_pkgHandle) < 0) {
- LogError("pkgmgrInstallerDestroyCertinfoSetHandle fail");
+ _E("pkgmgrInstallerDestroyCertinfoSetHandle fail");
}
}
void TaskPkgInfoUpdate::SetCertiInfo(int source)
{
- LogDebug("Set CertiInfo to pkgmgr : " << source);
+ _D("Set CertiInfo to pkgmgr : %d", source);
CertificateChainList certificateChainList;
m_context.widgetSecurity.getCertificateChainList(certificateChainList,
(CertificateSource)source);
FOREACH(it, certificateChainList)
{
- LogDebug("Insert certinfo to pkgmgr structure");
+ _D("Insert certinfo to pkgmgr structure");
ValidationCore::CertificateCollection chain;
if (false == chain.load(*it)) {
- LogError("Chain is broken");
+ _E("Chain is broken");
ThrowMsg(Exceptions::SetCertificateInfoFailed,
"Failed to Installer Save Certinfo");
}
if (!chain.sort()) {
- LogError("Chain failed at sorting");
+ _E("Chain failed at sorting");
}
ValidationCore::CertificateList list = chain.getCertificateList();
}
if (distributor1) {
- LogDebug("Set SIGNATURE_DISTRIBUTOR");
+ _D("Set SIGNATURE_DISTRIBUTOR");
if ((*certIt)->isRootCert()) {
instCertType = PM_SET_DISTRIBUTOR_ROOT_CERT;
} else {
}
}
} else {
- LogDebug("Set SIGNATURE_DISTRIBUTOR2");
+ _D("Set SIGNATURE_DISTRIBUTOR2");
if ((*certIt)->isRootCert()) {
instCertType = PM_SET_DISTRIBUTOR2_ROOT_CERT;
} else {
if ((*certIt)->isCA()) {
- instCertType =
- PM_SET_DISTRIBUTOR2_INTERMEDIATE_CERT;
+ instCertType = PM_SET_DISTRIBUTOR2_INTERMEDIATE_CERT;
} else {
instCertType = PM_SET_DISTRIBUTOR2_SIGNER_CERT;
}
}
}
} else {
- LogDebug("set SIGNATURE_AUTHOR");
+ _D("set SIGNATURE_AUTHOR");
if ((*certIt)->isRootCert()) {
instCertType = PM_SET_AUTHOR_ROOT_CERT;
} else {
}
}
}
- LogDebug("cert type : " << instCertType);
+ _D("cert type : %d", instCertType);
if ((pkgmgr_installer_set_cert_value(
m_pkgHandle,
instCertType,
const_cast<char*>(((*certIt)->getBase64()).c_str()))) < 0)
{
- LogError("pkgmgrInstallerSetCertValue fail");
+ _E("pkgmgrInstallerSetCertValue fail");
ThrowMsg(Exceptions::SetCertificateInfoFailed,
"Failed to Set CertValue");
}
m_context.widgetConfig.tzPkgid).c_str()))) <
0)
{
- LogError("pkgmgr_installer_delete_certinfo fail");
+ _E("pkgmgr_installer_delete_certinfo fail");
}
}
void TaskPkgInfoUpdate::StartStep()
{
- LogDebug("--------- <TaskPkgInfoUpdate> : START ----------");
+ _D("--------- <TaskPkgInfoUpdate> : START ----------");
}
void TaskPkgInfoUpdate::EndStep()
InstallerContext::INSTALL_SET_CERTINFO,
"Save certinfo to pkgmgr");
- LogDebug("--------- <TaskPkgInfoUpdate> : END ----------");
+ _D("--------- <TaskPkgInfoUpdate> : END ----------");
}
void TaskPkgInfoUpdate::stepAbortParseManifest()
{
- LogError("[Parse Manifest] Abroting....");
+ _E("[Parse Manifest] Abroting....");
int code = pkgmgr_parser_parse_manifest_for_uninstallation(
m_manifest.c_str(), NULL);
if (0 != code) {
- LogWarning("Manifest parser error: " << code);
+ _W("Manifest parser error: %d", code);
ThrowMsg(Exceptions::ManifestInvalid, "Parser returncode: " << code);
}
int ret = unlink(m_manifest.c_str());
if (0 != ret) {
- LogWarning("No manifest file found: " << m_manifest);
+ _W("No manifest file found: %s", m_manifest.c_str());
}
}
#include <dpl/file_output.h>
#include <dpl/file_input.h>
#include <dpl/copy.h>
-#include <dpl/log/log.h>
#include <dpl/wrt-dao-ro/feature_dao_read_only.h>
#include <dpl/foreach.h>
#include <widget_install/widget_install_context.h>
#include <widget_install_errors.h>
#include <task_commons.h>
+#include <installer_log.h>
namespace Jobs {
namespace WidgetInstall {
void TaskPrepareFiles::CopyFile(const std::string& source)
{
if (source.empty()) {
- LogWarning("No source file specified");
+ _W("No source file specified");
return;
}
std::string target =
m_installerContext.locations->getTemporaryPackageDir() + '/' +
filename;
- LogDebug("source " << source);
- LogDebug("target " << target);
+ _D("source %s", source.c_str());
+ _D("target %s", target.c_str());
Try
{
}
Catch(DPL::FileInput::Exception::Base)
{
- LogError("File input error");
+ _E("File input error");
// Error while opening or closing source file
ReThrowMsg(Exceptions::CopyIconFailed, source);
}
Catch(DPL::FileOutput::Exception::Base)
{
- LogError("File output error");
+ _E("File output error");
// Error while opening or closing target file
ReThrowMsg(Exceptions::CopyIconFailed, target);
}
Catch(DPL::CopyFailed)
{
- LogError("File copy error");
+ _E("File copy error");
// Error while copying
ReThrowMsg(Exceptions::CopyIconFailed, target);
}
+ 1);
}
- LogDebug("Icons copy...");
+ _D("Icons copy...");
FOREACH(it, m_installerContext.widgetConfig.configInfo.iconsList) {
std::ostringstream os;
- LogDebug("Coping: " << sourceDir << DPL::ToUTF8String(it->src));
+ _D("Coping: %s%ls", sourceDir.c_str(), (it->src).c_str());
os << sourceDir << DPL::ToUTF8String(it->src);
CopyFile(os.str());
}
void TaskPrepareFiles::StartStep()
{
- LogDebug("--------- <TaskPrepareFiles> : START ----------");
+ _D("--------- <TaskPrepareFiles> : START ----------");
}
void TaskPrepareFiles::EndStep()
{
- LogDebug("--------- <TaskPrepareFiles> : END ----------");
+ _D("--------- <TaskPrepareFiles> : END ----------");
}
} // namespace WidgetInstall
} // namespace Jobs
#include <dpl/task.h>
#include <dpl/string.h>
-#include <dpl/log/log.h>
#include <dpl/foreach.h>
#include <dpl/utils/wrt_utility.h>
#include <widget_install/widget_install_errors.h>
#include <widget_install/job_widget_install.h>
+#include <installer_log.h>
+
namespace Jobs {
namespace WidgetInstall {
namespace {
void createDir(const std::string& path)
{
if (WrtUtilMakeDir(path)) {
- LogDebug("Create directory : " << path);
+ _D("Create directory : %s", path.c_str());
} else {
ThrowMsg(Exceptions::RDSDeltaFailure, "Fail to create dir" << path);
}
void TaskPrepareReinstall::StepPrepare()
{
- LogDebug("Prepare");
+ _D("Prepare");
m_sourcePath = m_context.locations->getTemporaryPackageDir();
m_sourcePath += "/";
void TaskPrepareReinstall::StepParseRDSDelta()
{
- LogDebug("parse RDS delta");
+ _D("parse RDS delta");
std::string rdsDeltaPath = m_sourcePath;
rdsDeltaPath += ".rds_delta";
std::ifstream delta(rdsDeltaPath);
while (std::getline(delta, line) &&!delta.eof()) {
FOREACH(keyIt, keyList) {
if (line == *keyIt) {
- LogDebug("find key = [" << line << "]");
+ _D("find key = [%s]", line.c_str());
key = line;
break;
}
}
if (key == KEY_DELETE) {
m_deleteFileList.push_back(line);
- LogDebug("line = [" << line << "]");
+ _D("line = [%s]", line.c_str());
} else if (key == KEY_ADD) {
m_addFileList.push_back(line);
- LogDebug("line = [" << line << "]");
+ _D("line = [%s]", line.c_str());
} else if (key == KEY_MODIFY) {
m_modifyFileList.push_back(line);
- LogDebug("line = [" << line << "]");
+ _D("line = [%s]", line.c_str());
}
}
}
void TaskPrepareReinstall::StepVerifyRDSDelta()
{
- LogDebug("verify RDS delta");
+ _D("verify RDS delta");
// Verify ADD file
FOREACH(file, m_addFileList) {
std::string addFilePath = m_sourcePath;
existingFilePath += *file;
verifyFile(existingFilePath);
}
- LogDebug("Finished veify RDS Delta");
+ _D("Finished veify RDS Delta");
m_context.job->UpdateProgress(
InstallerContext::INSTALL_RDS_DELTA_CHECK,
void TaskPrepareReinstall::StepAddFile()
{
- LogDebug("Add file");
+ _D("Add file");
FOREACH(file, m_addFileList) {
std::string newfile = m_sourcePath;
newfile += *file;
ThrowMsg(Exceptions::RDSDeltaFailure,
"Fail to add file " << newfile);
}
- LogDebug("Add " << newfile << " to " << destPath);
+ _D("Add %s to %s", newfile.c_str(), destPath.c_str());
}
}
}
void TaskPrepareReinstall::StepDeleteFile()
{
- LogDebug("Delete file");
+ _D("Delete file");
FOREACH(file, m_deleteFileList) {
std::string deleteFilePath = m_installedPath;
deleteFilePath += *file;
ThrowMsg(Exceptions::RDSDeltaFailure,
"Fail to DELETE file " << deleteFilePath);
}
- LogDebug("Delete " << deleteFilePath);
+ _D("Delete %s", deleteFilePath.c_str());
}
}
void TaskPrepareReinstall::StepModifyFile()
{
- LogDebug("Modify file");
+ _D("Modify file");
FOREACH(file, m_modifyFileList) {
std::string destPath = m_installedPath;
destPath += *file;
ThrowMsg(Exceptions::RDSDeltaFailure,
"Fail to move new file" << destPath);
}
- LogDebug("Replace " << newfile << " to " << destPath);
+ _D("Replace %s to %s", newfile.c_str(), destPath.c_str());
}
}
void TaskPrepareReinstall::StartStep()
{
- LogDebug("--------- <TaskPrepareReinstall> : START ----------");
+ _D("---------- <TaskPrepareReinstall> : START ----------");
}
void TaskPrepareReinstall::EndStep()
InstallerContext::INSTALL_RDS_PREPARE,
"RDS prepare finished");
- LogDebug("--------- <TaskPrepareReinstall> : END ----------");
+ _D("---------- <TaskPrepareReinstall> : END ----------");
}
} //namespace WidgetInstall
#include <string>
#include <ail.h>
-#include <dpl/log/log.h>
#include <dpl/errno_string.h>
#include <dpl/foreach.h>
#include <widget_install/widget_install_context.h>
#include <widget_install/widget_install_errors.h>
+#include <installer_log.h>
+
using namespace WrtDB;
namespace Jobs {
void TaskRecovery::StartStep()
{
- LogDebug("--------- <TaskRecovery> : START ----------");
+ _D("---------- <TaskRecovery> : START ----------");
}
void TaskRecovery::EndStep()
InstallerContext::INSTALL_CHECK_FILE,
"Create information file for recovery");
- LogDebug("--------- <TaskRecovery> : END ----------");
+ _D("---------- <TaskRecovery> : END ----------");
}
void TaskRecovery::StepCreateCheckFile()
{
- LogDebug("Step: create information file for recovery");
+ _D("Step: create information file for recovery");
size_t pos = m_context.locations->getWidgetSource().rfind("/");
std::ostringstream infoPath;
m_context.installInfo = infoPath.str();
- LogDebug("Create file : " << m_context.installInfo);
+ _D("Create file : %s", m_context.installInfo.c_str());
} else {
ThrowMsg(Exceptions::FileOperationFailed, "Fail to create file for recovery.");
}
#include <sstream>
#include <dpl/wrt-dao-ro/global_config.h>
#include <dpl/foreach.h>
-#include <dpl/log/log.h>
#include <dpl/assert.h>
#include <dpl/utils/wrt_utility.h>
#include <dpl/wrt-dao-rw/widget_dao.h>
#include <widget_install/widget_install_errors.h>
#include <widget_install/widget_install_context.h>
#include <wrt-commons/widget-interface-dao/widget_interface_dao.h>
+#include <installer_log.h>
using namespace WrtDB;
backupDir << m_context.locations->getBackupDir();
if (WrtUtilRemove(backupDir.str())) {
- LogDebug("Success to remove backup files : " << backupDir.str());
+ _D("Success to remove backup files : %s", backupDir.str().c_str());
} else {
- LogError("Failed to remove backup directory : " << backupDir.str());
+ _E("Failed to remove backup directory : %s", backupDir.str().c_str());
ThrowMsg(Exceptions::RemoveBackupFailed,
"Error occurs during removing existing folder");
}
std::string tmp = m_context.locations->getTemporaryPackageDir();
if (WrtUtilRemove(tmp)) {
- LogDebug("Success to remove temp directory : " << tmp);
+ _D("Success to remove temp directory : %s", tmp.c_str());
} else {
- LogError("Failed to remove temp directory : " << tmp);
+ _E("Failed to remove temp directory : %s", tmp.c_str());
}
}
void TaskRemoveBackupFiles::StepDeleteBackupDB()
{
- LogDebug("StepDeleteBackupDB");
+ _D("StepDeleteBackupDB");
std::string oldAppid =
DPL::ToUTF8String(m_context.widgetConfig.tzAppid) + ".backup";
}
Catch(WidgetDAOReadOnly::Exception::WidgetNotExist)
{
- LogError("Fail to delete old version db information");
+ _E("Fail to delete old version db information");
}
}
void TaskRemoveBackupFiles::StepDeleteBackupWidgetInterfaceDB()
{
- LogDebug("StepDeleteBackupWidgetInterfaceDB");
+ _D("StepDeleteBackupWidgetInterfaceDB");
using namespace WidgetInterfaceDB;
using namespace WrtDB;
// remove backup database
if (remove(backupDbPath.c_str()) != 0) {
- LogWarning("Fail to remove");
+ _W("Fail to remove");
}
}
void TaskRemoveBackupFiles::StartStep()
{
- LogDebug("--------- <TaskRemoveBackupFiles> : START ----------");
+ _D("--------- <TaskRemoveBackupFiles> : START ----------");
}
void TaskRemoveBackupFiles::EndStep()
{
- LogDebug("--------- <TaskRemoveBackupFiles> : END ----------");
+ _D("--------- <TaskRemoveBackupFiles> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
#include <sys/smack.h>
#endif
#include <sstream>
+#include <installer_log.h>
using namespace WrtDB;
using namespace ValidationCore;
void TaskSmack::StepSetInstall()
{
- LogDebug("----------------> SMACK: StepStartSetSmack()");
+ _D("----------------> SMACK: StepStartSetSmack()");
#ifdef WRT_SMACK_ENABLED
std::string pkg = DPL::ToUTF8String(m_context.widgetConfig.tzPkgid);
m_pkgId = (char*)calloc(1, pkg.length() + 1);
void TaskSmack::StepSmackFolderLabeling()
{
- LogDebug("----------------> SMACK:\
+ _D("----------------> SMACK:\
Jobs::WidgetInstall::TaskSmack::SmackFolderLabelingStep()");
#ifdef WRT_SMACK_ENABLED
/* /opt/usr/apps/[pkgid] directory's label is "_" */
if (PC_OPERATION_SUCCESS != perm_app_setup_path(m_pkgId,
m_context.locations->getPackageInstallationDir().c_str(),
APP_PATH_ANY_LABEL, "_")) {
- LogWarning("Add label to " <<
- m_context.locations->getPackageInstallationDir());
+ _W("Add label to %s", m_context.locations->getPackageInstallationDir().c_str());
}
/* for prelaod */
if (PC_OPERATION_SUCCESS != perm_app_setup_path(m_pkgId, resDir.c_str(),
APP_PATH_PRIVATE)) {
- LogWarning("Add label to " << resDir);
+ _W("Add label to %s", resDir.c_str());
}
/* data directory */
if (PC_OPERATION_SUCCESS != perm_app_setup_path(m_pkgId,
m_context.locations->getPrivateStorageDir().c_str(),
APP_PATH_PRIVATE)) {
- LogWarning("Add label to " << m_context.locations->getPrivateStorageDir());
+ _W("Add label to %s", m_context.locations->getPrivateStorageDir().c_str());
}
/* tmp directory */
m_context.locations->getPrivateTempStorageDir().c_str(),
APP_PATH_PRIVATE))
{
- LogWarning("Add label to " << m_context.locations->getPrivateTempStorageDir());
+ _W("Add label to %s", m_context.locations->getPrivateTempStorageDir().c_str());
}
/* bin directory */
if (PC_OPERATION_SUCCESS != perm_app_setup_path(m_pkgId,
m_context.locations->getBinaryDir().c_str(),
APP_PATH_PRIVATE)) {
- LogWarning("Add label to " << m_context.locations->getBinaryDir());
+ _W("Add label to %s", m_context.locations->getBinaryDir().c_str());
}
if(!setLabelForSharedDir(m_pkgId)) {
- LogWarning("Add label to shared directory");
+ _W("Add label to shared directory");
}
free(m_pkgId);
void TaskSmack::StepSmackPrivilege()
{
- LogDebug("----------------> SMACK:\
- Jobs::WidgetInstall::TaskSmack::SmackPrivilegeStep()");
+ _D("----------------> SMACK:\
+ Jobs::WidgetInstall::TaskSmack::SmackPrivilegeStep()");
#ifdef WRT_SMACK_ENABLED
/* TODO :
std::string id = DPL::ToUTF8String(m_context.widgetConfig.tzAppid);
char** perm_list = new char*[privileges.size() + 1];
int index = 0;
FOREACH(it, privileges) {
- LogDebug("Permission : " << it->name);
+ _D("Permission : %ls", it->name.c_str());
int length = DPL::ToUTF8String(it->name).length();
char *priv = new char[length + 1];
snprintf(priv, length + 1, "%s",
if (PC_OPERATION_SUCCESS != perm_app_enable_permissions(appId, APP_TYPE_WGT,
const_cast<const char **>(perm_list), true)) {
- LogWarning("failure in contructing smack rules based on perm_list");
+ _W("failure in contructing smack rules based on perm_list");
}
free(appId);
void TaskSmack::StepRevokeForUpdate()
{
- LogDebug("----------------> SMACK:\
- Jobs::WidgetInstall::TaskSmack::StepRevokePrivilegeForUpdate()");
+ _D("----------------> SMACK:\
+ Jobs::WidgetInstall::TaskSmack::StepRevokePrivilegeForUpdate()");
#ifdef WRT_SMACK_ENABLED
if (PC_OPERATION_SUCCESS != perm_app_revoke_permissions(m_pkgId)) {
- LogWarning("failure in revoking smack permissions");
+ _W("failure in revoking smack permissions");
}
#endif
}
void TaskSmack::StepAbortSmack()
{
- LogDebug("----------------> SMACK:\
+ _D("----------------> SMACK:\
Jobs::WidgetInstall::TaskSmack::StepAbortSmack()");
#ifdef WRT_SMACK_ENABLED
if (PC_OPERATION_SUCCESS != perm_app_revoke_permissions(m_pkgId)) {
- LogWarning("failure in revoking smack permissions");
+ _W("failure in revoking smack permissions");
}
if (PC_OPERATION_SUCCESS != perm_app_uninstall(m_pkgId)) {
- LogWarning("failure in removing smack rules file");
+ _W("failure in removing smack rules file");
}
free(m_pkgId);
#endif
if (PC_OPERATION_SUCCESS != perm_app_setup_path(m_pkgId,
m_context.locations->getSharedRootDir().c_str(),
APP_PATH_ANY_LABEL, "_")) {
- LogWarning("Add label to " << m_context.locations->getUserDataRootDir());
+ _W("Add label to %s", m_context.locations->getUserDataRootDir().c_str());
}
/* /shared/res directory */
if (PC_OPERATION_SUCCESS != perm_app_setup_path(m_pkgId,
m_context.locations->getSharedResourceDir().c_str(),
APP_PATH_ANY_LABEL, "_")) {
- LogWarning("Add label to " << m_context.locations->getSharedResourceDir());
+ _W("Add label to %s", m_context.locations->getSharedResourceDir().c_str());
}
/* /shared/trusted directory */
iPos = sha1String.find("/");
}
- LogDebug("sha1 label string : " << sha1String);
+ _D("sha1 label string : %s", sha1String.c_str());
if (PC_OPERATION_SUCCESS != perm_app_setup_path(m_pkgId,
m_context.locations->getSharedTrustedDir().c_str(),
APP_PATH_GROUP_RW, sha1String.c_str())) {
- LogWarning("Add label to " << m_context.locations->getBinaryDir());
+ _W("Add label to %s", m_context.locations->getBinaryDir().c_str());
}
}
if (PC_OPERATION_SUCCESS != perm_app_setup_path(m_pkgId,
m_context.locations->getSharedDataDir().c_str(),
APP_PATH_PUBLIC_RO)) {
- LogWarning("Add label to " << m_context.locations->getSharedDataDir());
+ _W("Add label to %s", m_context.locations->getSharedDataDir().c_str());
}
return true;
void TaskSmack::StartStep()
{
- LogDebug("--------- <TaskSmack> : START ----------");
+ _D("--------- <TaskSmack> : START ----------");
}
void TaskSmack::EndStep()
{
- LogDebug("--------- <TaskSmack> : END ----------");
+ _D("--------- <TaskSmack> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
#include <widget_install/task_update_files.h>
#include <dpl/assert.h>
-#include <dpl/log/log.h>
#include <dpl/foreach.h>
#include <dpl/utils/wrt_utility.h>
#include <dpl/exception.h>
#include <dpl/errno_string.h>
+#include <installer_log.h>
+
using namespace WrtDB;
namespace {
void TaskUpdateFiles::StepBackupDirectory()
{
- LogDebug("StepCreateBackupFolder");
+ _D("StepCreateBackupFolder");
std::string backPath = m_context.locations->getBackupDir();
- LogDebug("Backup resource directory path : " << backPath);
+ _D("Backup resource directory path : %s", backPath.c_str());
std::string pkgPath = m_context.locations->getPackageInstallationDir();
if (0 == access(backPath.c_str(), F_OK)) {
"Error occurs during removing backup resource directory");
}
}
- LogDebug("copy : " << pkgPath << " to " << backPath);
+ _D("copy : %s to %s", pkgPath.c_str(), backPath.c_str());
if ((rename(pkgPath.c_str(), backPath.c_str())) != 0) {
- LogError("Failed to rename " << pkgPath << " to " << backPath);
+ _E("Failed to rename %s to %s", pkgPath.c_str(), backPath.c_str());
ThrowMsg(Exceptions::BackupFailed,
"Error occurs during rename file");
}
void TaskUpdateFiles::StepAbortBackupDirectory()
{
- LogDebug("StepAbortCopyFiles");
+ _D("StepAbortCopyFiles");
std::string backPath = m_context.locations->getBackupDir();
std::string pkgPath = m_context.locations->getPackageInstallationDir();
- LogDebug("Backup Folder " << backPath << " to " << pkgPath);
+ _D("Backup Folder %s to %s", backPath.c_str(), pkgPath.c_str());
if (!WrtUtilRemove(pkgPath)) {
- LogError("Failed to remove " << pkgPath);
+ _E("Failed to remove %s", pkgPath.c_str());
}
if (rename(backPath.c_str(), pkgPath.c_str()) != 0) {
- LogError("Failed to rename " << backPath << " to " << pkgPath);
+ _E("Failed to rename %s to %s", backPath.c_str(), pkgPath.c_str());
}
}
void TaskUpdateFiles::StartStep()
{
- LogDebug("--------- <TaskUpdateFiles> : START ----------");
+ _D("--------- <TaskUpdateFiles> : START ----------");
}
void TaskUpdateFiles::EndStep()
InstallerContext::INSTALL_CREATE_BACKUP_DIR,
"Backup directory created for update");
- LogDebug("--------- <TaskUpdateFiles> : END ----------");
+ _D("--------- <TaskUpdateFiles> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
#include <web_provider_livebox_info.h>
#include <manifest.h>
+#include <installer_log.h>
+
namespace { // anonymous
const DPL::String BR = DPL::FromUTF8String("<br>");
const std::string WIDGET_NOT_COMPATIBLE = "This widget is "
Try
{
std::string path = m_installContext.locations->getConfigurationDir();
- LogDebug("path: " << path);
+ _D("path: %s", path.c_str());
processFile(path, m_installContext.widgetConfig);
}
Catch(Exception::ConfigParseFailed)
{
- LogError("Parsing failed.");
+ _E("Parsing failed.");
ReThrow(Exceptions::WidgetConfigFileInvalid);
}
void TaskWidgetConfig::ReadLocaleFolders()
{
- LogDebug("Reading locale");
+ _D("Reading locale");
//Adding default locale
m_localeFolders.insert(L"");
m_installContext.locations->getConfigurationDir() + "/locales";
DIR* localeDir = opendir(localePath.c_str());
if (!localeDir) {
- LogDebug("No /locales directory in the widget package.");
+ _D("No /locales directory in the widget package.");
return;
}
absoluteDirName += dirent.d_name;
if (stat(absoluteDirName.c_str(), &statStruct) != 0) {
- LogError("stat() failed with " << DPL::GetErrnoString());
+ _E("stat() failed with %s", DPL::GetErrnoString().c_str());
continue;
}
if (S_ISDIR(statStruct.st_mode)) {
//Yes, we ignore current, parent & hidden directories
if (dirName[0] != L'.') {
- LogDebug("Adding locale directory \"" << dirName << "\"");
+ _D("Adding locale directory \"%ls\"", dirName.c_str());
m_localeFolders.insert(dirName);
}
}
}
if (return_code != 0 || errno != 0) {
- LogError("readdir_r() failed with " << DPL::GetErrnoString());
+ _E("readdir_r() failed with %s", DPL::GetErrnoString().c_str());
}
if (-1 == TEMP_FAILURE_RETRY(closedir(localeDir))) {
- LogError("Failed to close dir: " << localePath << " with error: "
- << DPL::GetErrnoString());
+ _E("Failed to close dir: %s with error: %s", localePath.c_str(), DPL::GetErrnoString().c_str());
}
}
void TaskWidgetConfig::ProcessIcon(const WrtDB::ConfigParserData::Icon& icon)
{
- LogDebug("enter");
+ _D("enter");
bool isAnyIconValid = false;
//In case a default filename is passed as custom filename in config.xml, we
//need to keep a set of already processed filenames to avoid icon
if (MimeTypeUtils::isMimeTypeSupportedForIcon(type)) {
isAnyIconValid = true;
localesAvailableForIcon.insert(*i);
- LogDebug("Icon absolutePath :" << absolutePath <<
- ", assigned locale :" << *i << ", type: " << type);
+ _D("Icon absolutePath: %ls, assigned locale: %ls, type: %ls",
+ absolutePath.c_str(), (*i).c_str(), type.c_str());
}
}
}
void TaskWidgetConfig::ProcessWidgetInstalledPath()
{
- LogDebug("ProcessWidgetInstalledPath");
+ _D("ProcessWidgetInstalledPath");
m_installContext.widgetConfig.widgetInstalledPath =
DPL::FromUTF8String(
m_installContext.locations->getPackageInstallationDir());
void TaskWidgetConfig::ProcessAppControlInfo()
{
- LogDebug("ProcessAppControlInfo");
+ _D("ProcessAppControlInfo");
using namespace WrtDB;
// In case of dispostion is inline, set the seperate execute
}
if (isSecurityModelV1 && isSecurityModelV2) {
- LogError("Security model is conflict");
+ _E("Security model is conflict");
ThrowMsg(Exceptions::NotAllowed, "Security model is conflict");
} else if (isSecurityModelV1) {
data.securityModelVersion =
m_installContext.widgetConfig.webAppType.appType,
m_installContext.widgetConfig.minVersion))
{
- LogError(
- "Platform version lower than required -> cancelling installation");
+ _E("Platform version lower than required -> cancelling installation");
ThrowMsg(Exceptions::NotAllowed,
"Platform version does not meet requirements");
}
if (!isFeatureAllowed(m_installContext.widgetConfig.webAppType.appType,
it->name))
{
- LogDebug("This application type not allowed to use this feature");
+ _D("This application type not allowed to use this feature");
ThrowMsg(
Exceptions::WidgetConfigFileInvalid,
"This app type [" <<
boxType = DPL::ToUTF8String((**it).m_type);
}
- LogDebug("livebox type: " << boxType);
+ _D("livebox type: %s", boxType.c_str());
ConfigParserData::LiveboxInfo::BoxSizeList boxSizeList =
(**it).m_boxInfo.m_boxSize;
free(boxSize);
if(!chkSize) {
- LogError("Invalid boxSize");
+ _E("Invalid boxSize");
ThrowMsg(Exceptions::WidgetConfigFileInvalid, "Invalid boxSize");
}
}
DPL::String featureName)
{
using namespace WrtDB;
- LogDebug("AppType = [" <<
- WidgetType(appType).getApptypeToString() << "]");
- LogDebug("FetureName = [" << featureName << "]");
+ _D("AppType = [%s]", WidgetType(appType).getApptypeToString().c_str());
+ _D("FetureName = [%ls]", featureName.c_str());
AppType featureType = APP_TYPE_UNKNOWN;
std::string featureStr = DPL::ToUTF8String(featureName);
std::istringstream inputString(version);
inputString >> majorVersion;
if (inputString.bad() || inputString.fail()) {
- LogWarning("Invalid minVersion format.");
+ _W("Invalid minVersion format.");
return false;
}
inputString.get(); // skip period
inputString >> minorVersion;
if (inputString.bad() || inputString.fail()) {
- LogWarning("Invalid minVersion format");
+ _W("Invalid minVersion format");
return false;
} else {
inputString.get(); // skip period
if (appType == WrtDB::AppType::APP_TYPE_TIZENWEBAPP) {
return false;
} else {
- LogWarning("minVersion attribute is empty. WRT assumes platform "
- "supports this widget.");
+ _W("minVersion attribute is empty. WRT assumes platform "
+ "supports this widget.");
return true;
}
}
if (!parseVersionString(DPL::ToUTF8String(*widgetVersion), majorWidget,
minorWidget, microWidget))
{
- LogWarning("Invalid format of widget version string.");
+ _W("Invalid format of widget version string.");
return false;
}
if (appType == WrtDB::AppType::APP_TYPE_TIZENWEBAPP) {
version = WrtDB::GlobalConfig::GetTizenVersion();
} else {
- LogWarning("Invaild AppType");
+ _W("Invaild AppType");
return false;
}
if (!parseVersionString(version,
majorSupported, minorSupported, microSupported))
{
- LogWarning("Invalid format of platform version string.");
+ _W("Invalid format of platform version string.");
return true;
}
(majorWidget == majorSupported && minorWidget == minorSupported
&& microWidget > microSupported))
{
- LogDebug("Platform doesn't support this widget.");
+ _D("Platform doesn't support this widget.");
return false;
}
return true;
}
Catch(ElementParser::Exception::Base)
{
- LogError("Invalid widget configuration file!");
+ _E("Invalid widget configuration file!");
return false;
}
return true;
WrtUtilJoinPaths(configFilePath, _currentPath, WRT_WIDGET_CONFIG_FILE_NAME);
if (!WrtUtilFileExists(configFilePath))
{
- LogError("Archive does not contain configuration file");
+ _E("Archive does not contain configuration file");
return false;
}
- LogDebug("Configuration file: " << configFilePath);
+ _D("Configuration file: %s", configFilePath.c_str());
Try
{
#ifdef SCHEMA_VALIDATION_ENABLED
if(!parser.Validate(configFilePath, WRT_WIDGETS_XML_SCHEMA))
{
- LogError("Invalid configuration file - schema validation failed");
+ _E("Invalid configuration file - schema validation failed");
return false;
}
#endif
}
Catch (ElementParser::Exception::Base)
{
- LogError("Invalid configuration file!");
+ _E("Invalid configuration file!");
return false;
}
}
pWidgetConfigInfo.guid = configInfo.widget_id;
} else {
if (pWidgetConfigInfo.guid != configInfo.widget_id) {
- LogError("Invalid archive");
+ _E("Invalid archive");
return false;
}
}
if (DPL::ToUTF8String(pWidgetConfigInfo.tzAppid).compare(
DPL::ToUTF8String(*configInfo.tizenAppId)) < 0)
{
- LogError("Invalid archive - Tizen App ID not same error");
+ _E("Invalid archive - Tizen App ID not same error");
return false;
}
}
if (!!configInfo.tizenPkgId) {
if (pWidgetConfigInfo.tzPkgid != *configInfo.tizenPkgId) {
- LogError("Invalid archive - Tizen Pkg ID not same error");
+ _E("Invalid archive - Tizen Pkg ID not same error");
return false;
}
}
pWidgetConfigInfo.version = configInfo.version;
} else {
if (pWidgetConfigInfo.version != configInfo.version) {
- LogError("Invalid archive");
+ _E("Invalid archive");
return false;
}
}
if (!locateAndParseConfigurationFile(path, widgetConfiguration,
DEFAULT_LANGUAGE))
{
- LogWarning("Widget archive: Failed while parsing config file");
+ _W("Widget archive: Failed while parsing config file");
ThrowMsg(Exception::ConfigParseFailed, path);
}
}
void TaskWidgetConfig::StartStep()
{
- LogDebug("--------- <TaskWidgetConfig> : START ----------");
+ _D("---------- <TaskWidgetConfig> : START ----------");
}
void TaskWidgetConfig::EndStep()
{
- LogDebug("--------- <TaskWidgetConfig> : END ----------");
+ _D("---------- <TaskWidgetConfig> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
#include <widget_install/widget_install_errors.h>
#include <widget_install/widget_install_context.h>
#include <widget_install/job_widget_install.h>
-#include <dpl/log/log.h>
#include <dpl/copy.h>
#include <dpl/file_output.h>
#include <dpl/abstract_waitable_input_adapter.h>
#include <task_commons.h>
#include <sys/stat.h>
#include <dlfcn.h>
+#include <installer_log.h>
using namespace WrtDB;
void WidgetUnzip::unzipProgress(const std::string &destination)
{
// Show file info
- LogDebug("Unzipping: '" << m_zipIterator->name <<
- "', Comment: '" << m_zipIterator->comment <<
- "', Compressed size: " << m_zipIterator->compressedSize <<
- ", Uncompressed size: " << m_zipIterator->uncompressedSize);
+ _D("Unzipping: '%s', Comment: '%s', Compressed size: %lld, Uncompressed size: %lld",
+ m_zipIterator->name.c_str(), m_zipIterator->comment.c_str(), m_zipIterator->compressedSize, m_zipIterator->uncompressedSize);
// Normalize file paths
// FIXME: Implement checking for invalid characters
// This is path
std::string newPath = destination + "/" +
fileName.substr(0, fileName.size() - 1);
- LogPedantic("Path to extract: " << newPath);
+ _D("Path to extract: %s", newPath.c_str());
// Create path in case of it is empty
createTempPath(newPath);
// This is regular file
std::string fileExtractPath = destination + "/" + fileName;
- LogPedantic("File to extract: " << fileExtractPath);
+ _D("File to extract: %s", fileExtractPath.c_str());
// Split into pat & file pair
PathAndFilePair pathAndFile = SplitFileAndPath(fileExtractPath);
- LogPedantic("Path and file: " <<
- pathAndFile.path <<
- " : " << pathAndFile.file);
+ _D("Path and file: %s : %s", pathAndFile.path.c_str(), pathAndFile.file.c_str());
// First, ensure that path exists
createTempPath(pathAndFile.path);
// Check whether there are more files to extract
if (++m_zipIterator == m_zip->end()) {
- LogDebug("Unzip progress finished successfuly");
+ _D("Unzip progress finished successfuly");
} else {
unzipProgress(destination);
}
bool WidgetUnzip::isDRMPackage(const std::string &source)
{
- LogDebug("Enter : isDRMPackage()");
+ _D("Enter : isDRMPackage()");
int ret = 0;
void* pHandle = NULL;
char* pErrorMsg = NULL;
pHandle = dlopen(DRM_LIB_PATH, RTLD_LAZY | RTLD_GLOBAL);
if (!pHandle) {
- LogError("dlopen failed : " << source << " [" << dlerror() << "]");
+ _E("dlopen failed : %s [%s]", source.c_str(), dlerror());
return false;
}
(dlsym(pHandle, "drm_oem_sapps_is_drm_file"));
pErrorMsg = dlerror();
if ((pErrorMsg != NULL) || (drm_oem_sapps_is_drm_file == NULL)) {
- LogError("dlopen failed : " << source << " [" << dlerror() << "]");
+ _E("dlopen failed : %s [%s]", source.c_str(), dlerror());
dlclose(pHandle);
return false;
}
ret = drm_oem_sapps_is_drm_file(source.c_str(), source.length());
dlclose(pHandle);
if (1 == ret) {
- LogDebug(source << " is DRM file");
+ _D("%s is DRM file", source.c_str());
return true;
}
- LogDebug(source << " isn't DRM file");
+ _D("%s isn't DRM file", source.c_str());
return false;
}
bool WidgetUnzip::decryptDRMPackage(const std::string &source, const std::string
&decryptedSource)
{
- LogDebug("Enter : decryptDRMPackage()");
+ _D("Enter : decryptDRMPackage()");
int ret = 0;
void* pHandle = NULL;
char* pErrorMsg = NULL;
pHandle = dlopen(DRM_LIB_PATH, RTLD_LAZY | RTLD_GLOBAL);
if (!pHandle) {
- LogError("dlopen failed : " << source << " [" << dlerror() << "]");
+ _E("dlopen failed : %s [%s]", source.c_str(), dlerror());
return false;
}
(dlsym(pHandle, "drm_oem_sapps_decrypt_package"));
pErrorMsg = dlerror();
if ((pErrorMsg != NULL) || (drm_oem_sapps_decrypt_package == NULL)) {
- LogError("dlopen failed : " << source << " [" << dlerror() << "]");
+ _E("dlopen failed : %s [%s]", source.c_str(), dlerror());
dlclose(pHandle);
return false;
}
decryptedSource.c_str(), decryptedSource.length());
dlclose(pHandle);
if (1 == ret) {
- LogDebug(source << " is decrypted : " << decryptedSource);
+ _D("%s is decrypted : %s", source.c_str(), decryptedSource.c_str());
return true;
}
return false;
std::string WidgetUnzip::getDecryptedPackage(const std::string &source)
{
- LogDebug("Check DRM...");
+ _D("Check DRM...");
if (isDRMPackage(source)) {
std::string decryptedFile;
size_t found = source.find_last_of(".wgt");
1) + "_tmp.wgt";
}
- LogDebug("decrypted file name : " << decryptedFile);
+ _D("decrypted file name : %s", decryptedFile.c_str());
if (!decryptDRMPackage(source, decryptedFile)) {
- LogError("Failed decrypt drm file");
+ _E("Failed decrypt drm file");
ThrowMsg(Exceptions::DrmDecryptFailed, source);
}
return decryptedFile;
void WidgetUnzip::unzipWgtFile(const std::string &source, const std::string &destination)
{
- LogDebug("Prepare to unzip...");
+ _D("Prepare to unzip...");
std::string wgtFile;
Try
{
wgtFile = getDecryptedPackage(source);
- LogDebug("wgtFile : " << wgtFile);
+ _D("wgtFile : %s", wgtFile.c_str());
m_zip.reset(new DPL::ZipInput(wgtFile));
- LogDebug("Widget package comment: " << m_zip->GetGlobalComment());
+ _D("Widget package comment: %s", m_zip->GetGlobalComment().c_str());
+
// Widget package must not be empty
if (m_zip->empty()) {
m_zip.reset();
// Done
- LogDebug("Unzip finished");
+ _D("Unzip finished");
}
Catch(DPL::ZipInput::Exception::OpenFailed)
{
#include <pkg-manager/pkgmgr_signal.h>
#include <app2ext_interface.h>
#include <dpl/utils/path.h>
+#include <installer_log.h>
using namespace WrtDB;
m_context.installedPath =
DPL::Utils::Path(*dao.getWidgetInstalledPath());
- LogDebug("Widget model exists. App id : " << m_context.tzAppid);
+ _D("Widget model exists. App id : %s", m_context.tzAppid.c_str());
// send start signal of pkgmgr
if (GetInstallerStruct().pkgmgrInterface->setPkgname(m_context.tzPkgid))
{
regex_t regx;
if(regcomp(®x, REG_TIZEN_PKGID_PATTERN, REG_NOSUB | REG_EXTENDED)!=0){
- LogDebug("Regcomp failed");
+ _D("Regcomp failed");
}
std::string pkgId;
DPL::Utils::Path installPath;
TizenAppId appid =
WrtDB::WidgetDAOReadOnly::getTzAppId(
DPL::FromUTF8String(id));
- LogDebug("Get appid from pkgid : " << appid);
+ _D("Get appid from pkgid : %ls", appid.c_str());
m_context.tzAppid = DPL::ToUTF8String(appid);
WrtDB::WidgetDAOReadOnly dao(appid);
installPath = DPL::Utils::Path(*dao.getWidgetInstalledPath());
installPath = DPL::Utils::Path(*dao.getWidgetInstalledPath());
}
if(installPath.isSubPath(PRELOAD_INSTALLED_PATH)){
- LogDebug("This widget is preloaded.");
+ _D("This widget is preloaded.");
}
} Catch(WidgetDAOReadOnly::Exception::WidgetNotExist) {
- LogDebug("package id : " << pkgId);
+ _D("package id : %s", pkgId.c_str());
m_context.tzPkgid = pkgId;
if (!pkgId.empty()) {
if(checkDirectoryExist(pkgId)) {
- LogError("installed widget status is abnormal");
+ _E("installed widget status is abnormal");
return WidgetStatus::ABNORMAL;
}
}
std::ostringstream percent;
percent << static_cast<int>(GetProgressPercent());
- LogDebug("Call widget uninstall progressCallback");
+ _D("Call widget uninstall progressCallback");
GetInstallerStruct().progressCallback(
GetInstallerStruct().userParam,
GetProgressPercent(), GetProgressDescription());
PKGMGR_END_KEY,
PKGMGR_END_SUCCESS);
- LogDebug("Call widget uninstall success finishedCallback");
+ _D("Call widget uninstall success finishedCallback");
GetInstallerStruct().finishedCallback(GetInstallerStruct().userParam,
getRemovedTizenId(),
Jobs::Exceptions::Success);
void JobWidgetUninstall::SendFinishedFailure()
{
using namespace PackageManager;
- LogError("Error in uninstallation step: " << m_exceptionCaught);
- LogError("Message: " << m_exceptionMessage);
+ _E("Error in uninstallation step: %d", m_exceptionCaught);
+ _E("Message: %s", m_exceptionMessage.c_str());
// send signal of pkgmgr
GetInstallerStruct().pkgmgrInterface->sendSignal(
PKGMGR_END_KEY,
PKGMGR_END_FAILURE);
- LogDebug("Call widget uninstall failure finishedCallback");
+ _D("Call widget uninstall failure finishedCallback");
GetInstallerStruct().finishedCallback(GetInstallerStruct().userParam,
getRemovedTizenId(),
m_exceptionCaught);
- LogDebug("[JobWidgetUninstall] Asynchronous failure callback status sent");
+ _D("[JobWidgetUninstall] Asynchronous failure callback status sent");
}
void JobWidgetUninstall::SaveExceptionData(const Jobs::JobExceptionBase &e)
#include <dpl/wrt-dao-ro/global_config.h>
#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
#include <app_manager.h>
+#include <installer_log.h>
namespace Jobs {
namespace WidgetUninstall {
void TaskCheck::StartStep()
{
- LogDebug("--------- <TaskCheck> : START ----------");
+ _D("--------- <TaskCheck> : START ----------");
}
void TaskCheck::EndStep()
{
m_context.job->UpdateProgress(UninstallerContext::UNINSTALL_PRECHECK,
"Uninstall pre-checking Finished");
- LogDebug("--------- <TaskCheck> : END ----------");
+ _D("--------- <TaskCheck> : END ----------");
}
void TaskCheck::StepUninstallPreCheck()
bool isRunning = false;
int ret = app_manager_is_running(m_context.tzAppid.c_str(), &isRunning);
if (APP_MANAGER_ERROR_NONE != ret) {
- LogError("Fail to get running state");
+ _E("Fail to get running state");
ThrowMsg(Exceptions::PlatformAPIFailure,
"Fail to get widget state");
}
app_context_h appCtx = NULL;
ret = app_manager_get_app_context(m_context.tzAppid.c_str(), &appCtx);
if (APP_MANAGER_ERROR_NONE != ret) {
- LogError("Fail to get app_context");
+ _E("Fail to get app_context");
ThrowMsg(Exceptions::AppIsRunning,
"Widget is not stopped. Cannot uninstall!");
}
// terminate app_context_h
ret = app_manager_terminate_app(appCtx);
if (APP_MANAGER_ERROR_NONE != ret) {
- LogError("Fail to terminate running application");
+ _E("Fail to terminate running application");
app_context_destroy(appCtx);
ThrowMsg(Exceptions::AppIsRunning,
"Widget is not stopped. Cannot uninstall!");
nanosleep(&duration, NULL);
int ret = app_manager_is_running(m_context.tzAppid.c_str(), &isStillRunning);
if (APP_MANAGER_ERROR_NONE != ret) {
- LogError("Fail to get running state");
+ _E("Fail to get running state");
ThrowMsg(Exceptions::PlatformAPIFailure,
"Fail to get widget state");
}
}
}
if (isStillRunning) {
- LogError("Fail to terminate running application");
+ _E("Fail to terminate running application");
ThrowMsg(Exceptions::AppIsRunning,
"Widget is not stopped. Cannot uninstall!");
}
- LogDebug("terminate application");
+ _D("terminate application");
}
}
- LogDebug("Widget Can be uninstalled. Pkgname : " << m_context.tzAppid);
+ _D("Widget Can be uninstalled, Pkgname : %s", m_context.tzAppid.c_str());
}
} //namespace WidgetUninstall
} //namespace Jobs
#include <dpl/assert.h>
#include <ace-common/ace_api_common.h>
#include <dpl/wrt-dao-rw/widget_dao.h>
+#include <installer_log.h>
using namespace WrtDB;
tzAppid))));
WidgetDAO::unregisterWidget(DPL::FromUTF8String(m_context.tzAppid));
- LogDebug("Unregistered widget successfully!");
+ _D("Unregistered widget successfully!");
}
Catch(DPL::DB::SqlConnection::Exception::Base)
{
- LogError("Failed to handle StepDbUpdate!");
+ _E("Failed to handle StepDbUpdate!");
ReThrowMsg(Exceptions::DatabaseFailure,
"Failed to handle StepDbUpdate!");
}
web_provider_livebox_delete_by_app_id(m_context.tzAppid.c_str());
if (ret < 0) {
- LogDebug("failed to delete box info");
+ _D("failed to delete box info");
} else {
- LogDebug("delete box info: " << m_context.tzAppid);
+ _D("delete box info: %s", m_context.tzAppid.c_str());
}
}
{
if (!m_context.removeAbnormal) {
WidgetDAO dao(DPL::FromUTF8String(m_context.tzAppid));
- LogDebug("Removing external locations:");
+ _D("Removing external locations:");
WrtDB::ExternalLocationList externalPaths = dao.getWidgetExternalLocations();
FOREACH(file, externalPaths)
{
DPL::Utils::Path path(*file);
if(path.Exists()){
if(path.IsFile()){
- LogDebug(" -> " << path.Fullpath());
+ _D(" -> %s", path.Fullpath().c_str());
Try{
DPL::Utils::Remove(path);
}Catch(DPL::Utils::Path::BaseException){
- LogError("Failed to remove the file: " << path.Fullpath());
+ _E("Failed to remove the file: %s", path.Fullpath().c_str());
}
} else if (path.IsDir()){
- LogDebug(" -> " << path.Fullpath());
+ _D(" -> %s", path.Fullpath().c_str());
Try{
DPL::Utils::Remove(path);
}Catch(DPL::Utils::Path::BaseException){
}
}
}else{
- LogWarning(" -> " << path.Fullpath() << "(no such a path)");
+ _W(" -> %s(no such a path)", path.Fullpath().c_str());
}
}
dao.unregisterAllExternalLocations();
void TaskDbUpdate::StartStep()
{
- LogDebug("--------- <TaskDbUpdate> : START ----------");
+ _D("--------- <TaskDbUpdate> : START ----------");
}
void TaskDbUpdate::EndStep()
UninstallerContext::UNINSTALL_DB_UPDATE,
"Widget DB Update Finished");
- LogDebug("--------- <TaskDbUpdate> : END ----------");
+ _D("--------- <TaskDbUpdate> : END ----------");
}
} //namespace WidgetUninstall
} //namespace Jobs
#include <dpl/assert.h>
#include <dpl/utils/wrt_utility.h>
#include <dpl/utils/path.h>
+#include <installer_log.h>
namespace Jobs {
namespace WidgetUninstall {
void TaskDeletePkgInfo::StartStep()
{
- LogDebug("--------- <TaskDeletePkgInfo> : START ----------");
+ _D("--------- <TaskDeletePkgInfo> : START ----------");
}
void TaskDeletePkgInfo::EndStep()
{
- LogDebug("--------- <TaskDeletePkgInfo> : END ----------");
+ _D("--------- <TaskDeletePkgInfo> : END ----------");
}
void TaskDeletePkgInfo::StepDeletePkgInfo()
if (0 == (m_context.installedPath.Fullpath()).compare(0,
PRELOAD_INSTALLED_PATH.Fullpath().length(),
PRELOAD_INSTALLED_PATH.Fullpath())) {
- LogDebug("This widget is preloaded.");
+ _D("This widget is preloaded.");
destFile = USR_PACKAGES_PATH;
} else {
destFile = OPT_PACKAGES_PATH;
if (!(destFile.Exists() == 0 && pre_manifest.Exists())) {
if (0 != pkgmgr_parser_parse_manifest_for_uninstallation(
destFile.Fullpath().c_str(), NULL)) {
- LogWarning("Manifest file failed to parse for uninstallation");
+ _W("Manifest file failed to parse for uninstallation");
}
}
if (!DPL::Utils::TryRemove(destFile)) {
- LogWarning("No manifest file found: " << destFile.Fullpath());
+ _W("No manifest file found: %s", destFile.Fullpath().c_str());
} else {
- LogDebug("Manifest file removed: " << destFile.Fullpath());
+ _D("Manifest file removed: %s", destFile.Fullpath().c_str());
}
}
} //namespace WidgetUninstall
#include <widget_uninstall/task_remove_custom_handlers.h>
#include <widget_uninstall/uninstaller_context.h>
-#include <dpl/log/log.h>
#include <dpl/optional_typedefs.h>
#include <appsvc.h>
#include <wrt-commons/custom-handler-dao-ro/CustomHandlerDatabase.h>
#include <wrt-commons/custom-handler-dao-rw/custom_handler_dao.h>
+#include <installer_log.h>
namespace Jobs {
namespace WidgetUninstall {
void TaskRemoveCustomHandlers::Step()
{
- LogDebug("Removing widget from appsvc");
+ _D("Removing widget from appsvc");
int result = appsvc_unset_defapp(m_context.tzAppid.c_str());
- LogDebug("Result: " << result);
+ _D("Result: %d", result);
CustomHandlerDB::Interface::attachDatabaseRW();
CustomHandlerDB::CustomHandlerDAO handlersDao(
void TaskRemoveCustomHandlers::StartStep()
{
- LogDebug("--------- <TaskRemoveCustomHandlers> : START ----------");
+ _D("--------- <TaskRemoveCustomHandlers> : START ----------");
}
void TaskRemoveCustomHandlers::EndStep()
{
- LogDebug("--------- <TaskRemoveCustomHandlers> : END ----------");
+ _D("--------- <TaskRemoveCustomHandlers> : END ----------");
}
} //namespace WidgetUninstall
} //namespace Jobs
#include <errno.h>
#include <string.h>
#include <widget_install_to_external.h>
+#include <installer_log.h>
namespace Jobs {
namespace WidgetUninstall {
void TaskRemoveFiles::StepRemoveInstallationDirectory()
{
- LogDebug("StepRemoveInstallationDirectory started");
+ _D("StepRemoveInstallationDirectory started");
Try {
int ret = app2ext_get_app_location(m_context.tzPkgid.c_str());
if (APP2EXT_INTERNAL_MEM == ret) {
- LogDebug("Removing directory");
+ _D("Removing directory");
m_context.removeStarted = true;
DPL::Utils::Path widgetDir= m_context.installedPath;
Try{
DPL::Utils::Remove(widgetDir);
} Catch(DPL::Utils::Path::BaseException){
- LogError("Removing widget installation directory failed : " <<
- widgetDir.Fullpath());
+ _E("Removing widget installation directory failed : %s", widgetDir.Fullpath().c_str());
}
DPL::Utils::Path dataDir(m_context.locations->getUserDataRootDir());
Try{
DPL::Utils::Remove(dataDir);
} Catch(DPL::Utils::Path::BaseException){
- LogWarning(dataDir.Fullpath() << " is already removed");
+ _W("%s is already removed", dataDir.Fullpath().c_str());
}
} else if (APP2EXT_SD_CARD == ret) {
- LogDebug("Removing sdcard directory");
+ _D("Removing sdcard directory");
Try {
WidgetInstallToExtSingleton::Instance().initialize(m_context.tzPkgid);
WidgetInstallToExtSingleton::Instance().uninstallation();
RemoveFilesFailed);
}
} else {
- LogError("app is not installed");
+ _E("app is not installed");
ThrowMsg(Exceptions::WidgetNotExist, "failed to get app location");
}
} Catch(Exception::RemoveFilesFailed) {
void TaskRemoveFiles::StepRemoveFinished()
{
- LogDebug("StepRemoveFinished finished");
+ _D("StepRemoveFinished finished");
m_context.job->UpdateProgress(
UninstallerContext::UNINSTALL_REMOVE_FINISHED,
void TaskRemoveFiles::StartStep()
{
- LogDebug("--------- <TaskRemoveFiles> : START ----------");
+ _D("--------- <TaskRemoveFiles> : START ----------");
}
void TaskRemoveFiles::EndStep()
{
- LogDebug("--------- <TaskRemoveFiles> : END ----------");
+ _D("--------- <TaskRemoveFiles> : END ----------");
}
} //namespace WidgetUninstall
} //namespace Jobs
#include <widget_uninstall/task_smack.h>
#include <widget_uninstall/job_widget_uninstall.h>
#include <widget_uninstall/uninstaller_context.h>
-#include <dpl/log/log.h>
#include <dpl/optional_typedefs.h>
+#include <installer_log.h>
+
#ifdef WRT_SMACK_ENABLED
#include <privilege-control.h>
#endif
void TaskSmack::Step()
{
- LogDebug(
- "------------------------> SMACK: Jobs::WidgetUninstall::TaskSmack::Step()");
+ _D("------------------------> SMACK: Jobs::WidgetUninstall::TaskSmack::Step()");
#ifdef WRT_SMACK_ENABLED
const char* pkgId = m_context.tzPkgid.c_str();
if (PC_OPERATION_SUCCESS != perm_app_revoke_permissions(pkgId)) {
- LogError("failure in revoking smack permissions");
+ _E("failure in revoking smack permissions");
}
if (PC_OPERATION_SUCCESS != perm_app_uninstall(pkgId)) {
- LogError("failure in removing smack rules file");
+ _E("failure in removing smack rules file");
}
#endif
}
void TaskSmack::StartStep()
{
- LogDebug("--------- <TaskSmack> : START ----------");
+ _D("--------- <TaskSmack> : START ----------");
}
void TaskSmack::EndStep()
UninstallerContext::UNINSTALL_SMACK_DISABLE,
"Widget SMACK Disabled");
- LogDebug("--------- <TaskSmack> : END ----------");
+ _D("--------- <TaskSmack> : END ----------");
}
} //namespace WidgetUninstall
} //namespace Jobs
#include <widget_uninstall/widget_uninstall_errors.h>
#include <dpl/wrt-dao-ro/global_config.h>
#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
+#include <installer_log.h>
using namespace WrtDB;
void TaskUninstallOspsvc::StepUninstallOspsvc()
{
- LogDebug("Step : Uninstall Osp service ");
+ _D("Step : Uninstall Osp service");
std::ostringstream commStr;
commStr << OSP_INSTALL_STR << BashUtils::escape_arg(m_context.tzPkgid);
- LogDebug("osp uninstall command : " << commStr.str());
+ _D("osp uninstall command : %s", commStr.str().c_str());
char readBuf[MAX_BUF_SIZE];
FILE *fd;
fd = popen(commStr.str().c_str(), "r");
if (NULL == fd) {
- LogError("Failed to uninstalltion osp service");
+ _E("Failed to uninstalltion osp service");
ThrowMsg(Exceptions::UninstallOspSvcFailed,
"Error occurs during\
uninstall osp service");
if(fgets(readBuf, MAX_BUF_SIZE, fd) == NULL)
{
- LogError("Failed to uninstalltion osp service\
+ _E("Failed to uninstalltion osp service\
Inability of reading file.");
ThrowMsg(Exceptions::UninstallOspSvcFailed,
"Error occurs during\
uninstall osp service");
}
- LogDebug("return value : " << readBuf);
+ _D("return value : %s", readBuf);
int result = atoi(readBuf);
if (0 != result) {
pclose(fd);
- LogDebug("Widget Can be uninstalled. Pkgname : " << m_context.tzPkgid);
+ _D("Widget Can be uninstalled. Pkgname : %s", m_context.tzPkgid.c_str());
m_context.job->UpdateProgress(UninstallerContext::UNINSTALL_REMOVE_OSPSVC,
"Uninstall OSP service finished");
}
void TaskUninstallOspsvc::StartStep()
{
- LogDebug("--------- <TaskUninstallOspsvc> : START ----------");
+ _D("--------- <TaskUninstallOspsvc> : START ----------");
}
void TaskUninstallOspsvc::EndStep()
{
- LogDebug("--------- <TaskUninstallOspsvc> : END ----------");
+ _D("--------- <TaskUninstallOspsvc> : END ----------");
}
} //namespace WidgetUninstall
} //namespace Jobs
* limitations under the License.
*/
#include "installer_controller.h"
-#include <dpl/log/log.h>
#include <dpl/singleton_impl.h>
IMPLEMENT_SINGLETON(Logic::InstallerController)
#include <plugin_install/job_plugin_install.h>
#include <job_exception_base.h>
#include <plugin_install/plugin_objects.h>
+#include <installer_log.h>
using namespace WrtDB;
void InstallerLogic::Initialize()
{
- LogDebug("Done");
+ _D("Done");
}
void InstallerLogic::Terminate()
if(m_job)
m_job->SetPaused(true);
- LogDebug("Done");
+ _D("Done");
}
Jobs::JobHandle InstallerLogic::AddAndStartJob()
{
if(m_job)
{
- LogError("Job is in progress. It is impossible to add new job");
+ _E("Job is in progress. It is impossible to add new job");
return -1;
}
- LogDebug("New Widget Installation:");
+ _D("New Widget Installation:");
m_job =
new Jobs::WidgetInstall::JobWidgetInstall(widgetPath, installerStruct);
{
if(m_job)
{
- LogError("Job is in progress. It is impossible to add new job");
+ _E("Job is in progress. It is impossible to add new job");
return -1;
}
- LogDebug("New Widget Uninstallation");
+ _D("New Widget Uninstallation");
m_job =
new Jobs::WidgetUninstall::JobWidgetUninstall(widgetPkgName,
{
if(m_job)
{
- LogError("Job is in progress. It is impossible to add new job");
+ _E("Job is in progress. It is impossible to add new job");
return -1;
}
- LogDebug("New Plugin Installation");
+ _D("New Plugin Installation");
// TODO Conversion to PluginPath is temporary
m_job =
return false;
} catch (Jobs::JobExceptionBase &exc) {
//start revert job
- LogDebug("Exception occured: " << exc.getParam() <<
- ". Reverting job...");
+ _D("Exception occured: %d. Reverting job...", exc.getParam());
bool hasAbortSteps = job->Abort();
job->SetAbortStarted(true);
job->SaveExceptionData(exc);
if (depHandle ==
Jobs::PluginInstall::JobPluginInstall::INVALID_HANDLE)
{
- LogError("Library implementing: " <<
- *requiredObject << " NOT FOUND");
+ _E("Library implementing: %s NOT FOUND", (*requiredObject).c_str());
//PluginDAO::SetPluginInstallationStatus(INSTALLATION_WAITING);
return false;
#include <widget_uninstall/widget_uninstaller_struct.h>
#include <plugin_install/plugin_installer_struct.h>
#include <job.h>
+#include <installer_log.h>
namespace Logic {
class InstallerLogic
//TODO implement me
bool AbortJob(const Jobs::JobHandle & /*handle*/)
{
- LogWarning("Not implemented");
+ _W("Not implemented");
return true;
}
#include <dpl/noncopyable.h>
#include <dpl/string.h>
#include <dpl/foreach.h>
-#include <dpl/log/log.h>
#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
#include <dpl/wrt-dao-ro/global_dao_read_only.h>
+#include <installer_log.h>
namespace Jobs {
namespace WidgetInstall {
WrtDB::WidgetDAOReadOnly widgetDao(tzAppid);
WidgetFeatureSet featureSet = widgetDao.getFeaturesList();
FOREACH(it, featureSet) {
- LogDebug("Feature name : " << it->name);
+ _D("Feature name : %ls", it->name.c_str());
WrtDB::DeviceCapabilitySet dcs;
if (!DPL::StringCompare(it->name, PRIVILEGE_TESTAUTOMATION)) {
// special privilege
dcs = WrtDB::GlobalDAOReadOnly::GetDeviceCapability(it->name);
}
FOREACH(devCap, dcs) {
- LogDebug("--- dev cap : " << *devCap);
+ _D("--- dev cap : %ls", (*devCap).c_str());
}
Feature feature(*it, dcs);
m_featureList.push_back(feature);
#include "libxml_utils.h"
#include <dpl/singleton_impl.h>
+#include <installer_log.h>
IMPLEMENT_SINGLETON(LibxmlUtils)
LibxmlUtils::~LibxmlUtils()
{
if (isInitialized) {
- LogDebug("Libxml - cleaning");
+ _D("Libxml - cleaning");
// Cleanup function for the XML library.
xmlCleanupParser();
//this is to debug memory for regression tests
if (!isInitialized) {
LIBXML_TEST_VERSION
isInitialized = true;
- LogDebug("Libxml have been initialized");
+ _D("Libxml have been initialized");
}
- LogDebug("Libxml already initialized");
+ _D("Libxml already initialized");
}
#include <memory>
#include <string>
-#include <dpl/log/log.h>
#include <dpl/string.h>
#include <iri.h>
+#include <installer_log.h>
namespace {
const char *SCHEME_HTTP = "http";
bool WacWidgetId::matchHost(const DPL::String &second) const
{
- LogDebug("m_schemaMatch is: " << m_schemaMatch);
+ _D("m_schemaMatch is: %d", m_schemaMatch);
if (!m_schemaMatch) {
return false;
}
- LogDebug("Matching DNS identity: " << m_host <<
- " " << DPL::ToUTF8String(second));
+ _D("Matching DNS identity: %s %ls", m_host.c_str(), second.c_str());
return m_host == DPL::ToUTF8String(second);
}
void WacWidgetId::parse(const char *url)
{
- LogDebug("Widget id to parse: " << url);
+ _D("Widget id to parse: %s", url);
std::unique_ptr<iri_struct, std::function<void(iri_struct*)> >
iri(iri_parse(url), iri_destroy);
if (!iri.get()) {
- LogError("Error in parsing widget id.");
+ _E("Error in parsing widget id.");
return; // m_schemaMatch == false;
}
if (iri.get()->scheme) {
scheme = iri.get()->scheme;
} else {
- LogWarning("Error. No scheme in widget id.");
+ _W("Error. No scheme in widget id.");
return; // m_schemaMatch == false;
}
// We only match "http" and "https" schemas
if ((scheme != SCHEME_HTTP) && (scheme != SCHEME_HTTPS)) {
- LogWarning("Unknown scheme in widget id." << scheme);
+ _W("Unknown scheme in widget id. %s", scheme.c_str());
return; // m_schemaMatch == false;
} else {
m_schemaMatch = true;
if (iri.get()->host) {
m_host = iri.get()->host;
- LogDebug("Host has been set to: " << m_host);
+ _D("Host has been set to: %s", m_host.c_str());
}
// What to do when host is empty? No info in wac documentation.
#include <dpl/singleton_safe_impl.h>
#include <dpl/assert.h>
-#include <dpl/log/log.h>
+#include <installer_log.h>
IMPLEMENT_SAFE_SINGLETON(WidgetInstallToExt)
void WidgetInstallToExt::initialize(std::string appId)
{
- LogDebug("WidgetInstallToExt::initialize()");
+ _D("WidgetInstallToExt::initialize()");
m_appId = appId;
m_handle = app2ext_init(APP2EXT_SD_CARD);
void WidgetInstallToExt::deinitialize()
{
- LogDebug("WidgetInstallToExt::deinitialize()");
+ _D("WidgetInstallToExt::deinitialize()");
if (NULL != m_handle) {
if (0 < app2ext_deinit(m_handle)) {
ThrowMsg(Exception::ErrorInstallToExt,
void WidgetInstallToExt::preInstallation(GList *dirList, int dSize)
{
- LogDebug("WidgetInstallToExt::preInstallation()");
+ _D("WidgetInstallToExt::preInstallation()");
Assert(m_handle);
int ret = m_handle->interface.pre_install(m_appId.c_str(), dirList, dSize);
if (APP2EXT_SUCCESS == ret) {
- LogDebug("App2Ext pre install success");
+ _D("App2Ext pre install success");
} else {
postInstallation(false);
ThrowMsg(Exception::ErrorInstallToExt, "pre-install failed");
void WidgetInstallToExt::postInstallation(bool status)
{
- LogDebug("WidgetInstallToExt::postInstallation()");
+ _D("WidgetInstallToExt::postInstallation()");
if (NULL != m_handle) {
if (status) {
void WidgetInstallToExt::preUpgrade(GList *dirList, int dSize)
{
- LogDebug("WidgetInstallToExt::preUpgrade()");
+ _D("WidgetInstallToExt::preUpgrade()");
Assert(m_handle);
int ret = m_handle->interface.pre_upgrade(m_appId.c_str(), dirList, dSize);
if (APP2EXT_SUCCESS == ret) {
- LogDebug("App2Ext pre-upgrade success");
+ _D("App2Ext pre-upgrade success");
} else {
postUpgrade(false);
ThrowMsg(Exception::ErrorInstallToExt, "pre-upgrade failed");
void WidgetInstallToExt::postUpgrade(bool status)
{
- LogDebug("WidgetInstallToExt::postUpgrade()");
+ _D("WidgetInstallToExt::postUpgrade()");
if (NULL != m_handle) {
if (status) {
m_handle->interface.post_upgrade(m_appId.c_str(),
void WidgetInstallToExt::uninstallation()
{
- LogDebug("WidgetInstallToExt::uninstallation()");
+ _D("WidgetInstallToExt::uninstallation()");
Assert(m_handle);
if (APP2EXT_SUCCESS ==
m_handle->interface.post_uninstall(m_appId.c_str()))
{
- LogDebug("App2Ext pre-uninstall success");
+ _D("App2Ext pre-uninstall success");
} else {
ThrowMsg(Exception::ErrorInstallToExt, "post-uninstall failed");
}
#include <dpl/utils/wrt_utility.h>
#include <dpl/wrt-dao-ro/global_config.h>
#include <dpl/assert.h>
-#include <dpl/log/log.h>
#include <dpl/sstream.h>
#include <dpl/localization/localization_utils.h>
#include <widget_install/task_commons.h>
+#include <installer_log.h>
WidgetLocation::DirectoryDeletor::DirectoryDeletor(bool isReadOnly) :
m_dirpath(Jobs::WidgetInstall::createTempPath(isReadOnly))
WidgetLocation::DirectoryDeletor::~DirectoryDeletor()
{
- LogDebug(
- "Removing widget installation temporary directory: " << m_dirpath.c_str());
+ _D("Removing widget installation temporary directory: %s", m_dirpath.c_str());
if (!WrtUtilRemove(m_dirpath)) {
- LogWarning("Fail at removing directory: " << m_dirpath.c_str());
+ _W("Fail at removing directory: %s", m_dirpath.c_str());
}
}
std::string WidgetLocation::getBackupSharedTrustedDir() const
{
return getBackupSharedDir() + "/trusted";
-}
\ No newline at end of file
+}
#include "package-manager-plugin.h"
#include <package-manager.h>
#include <regex.h>
-#include <dlog.h>
#include <dpl/wrt-dao-ro/global_config.h>
#include <vcore/VCore.h>
#include <dpl/wrt-dao-ro/WrtDatabase.h>
#include <dpl/wrt-dao-ro/widget_config.h>
#include <string>
#include <dpl/db/sql_connection.h>
-#include <dpl/log/log.h>
#include <dpl/foreach.h>
#include <dpl/utils/folder_size.h>
#include <dpl/wrt-dao-ro/wrt_db_types.h>
#include "root_parser.h"
#include "widget_parser.h"
#include "parser_runner.h"
+#include <installer_log.h>
using namespace WrtDB;
static void pkg_native_plugin_on_unload()
{
- LogDebug("pkg_native_plugin_unload() is called");
+ _D("pkg_native_plugin_unload() is called");
}
static int pkg_plugin_app_is_installed(const char *pkg_name)
{
const char* REG_PKGID_PATTERN = "^[a-zA-Z0-9]{10}$";
- LogDebug("pkg_plugin_app_is_installed() is called");
+ _D("pkg_plugin_app_is_installed() is called");
WrtDB::WrtDatabase::attachToThreadRO();
regex_t reg;
if (regcomp(®, REG_PKGID_PATTERN, REG_NOSUB | REG_EXTENDED) != 0) {
- LogDebug("Regcomp failed");
+ _D("Regcomp failed");
}
WrtDB::TizenAppId appid;
if (!(regexec(®, pkg_name,
static_cast<size_t>(0), NULL, 0) == 0))
{
- LogError("Invalid argument : " << pkg_name);
+ _E("Invalid argument : %s", pkg_name);
return FALSE;
}
Try {
WrtDB::TizenPkgId pkgid(DPL::FromUTF8String(pkg_name));
appid = WidgetDAOReadOnly::getTzAppId(pkgid);
- LogDebug("appid : " << appid);
+ _D("appid : %ls", appid.c_str());
} Catch(WidgetDAOReadOnly::Exception::WidgetNotExist) {
WrtDB::WrtDatabase::detachFromThread();
return FALSE;
package_manager_pkg_info_t **list,
int *count)
{
- LogDebug("pkg_plugin_get_installed_apps_list() is called");
+ _D("pkg_plugin_get_installed_apps_list() is called");
package_manager_pkg_info_t *pkg_list = NULL;
package_manager_pkg_info_t *pkg_last = NULL;
package_manager_pkg_detail_info_t *
pkg_detail_info)
{
- LogDebug("pkg_plugin_get_app_detail_info() is called");
+ _D("pkg_plugin_get_app_detail_info() is called");
WrtDB::WrtDatabase::attachToThreadRO();
Try {
WrtDB::TizenPkgId pkgid(DPL::FromUTF8String(pkg_name));
appid = WidgetDAOReadOnly::getTzAppId(pkgid);
- LogDebug("appid : " << appid);
+ _D("appid : %ls", appid.c_str());
} Catch(WidgetDAOReadOnly::Exception::WidgetNotExist) {
WrtDB::WrtDatabase::detachFromThread();
return FALSE;
WidgetLocalizedInfo localizedInfo;
if (locale.IsNull()) {
- LogDebug("locale is NULL");
+ _D("locale is NULL");
DPL::String languageTag(L"");
localizedInfo = widget.getLocalizedInfo(languageTag);
} else {
}
Catch(DPL::ZipInput::Exception::OpenFailed)
{
- LogError("Failed to open widget package");
+ _E("Failed to open widget package");
return FALSE;
}
Catch(DPL::ZipInput::Exception::OpenFileFailed)
{
- LogError("Failed to open config.xml file");
+ _E("Failed to open config.xml file");
return FALSE;
}
Catch(DPL::CopyFailed)
{
- LogError("Failed to extract config.xml file");
+ _E("Failed to extract config.xml file");
return FALSE;
}
Catch(DPL::FileInput::Exception::OpenFailed)
{
- LogError("Failed to open config.xml file");
+ _E("Failed to open config.xml file");
return FALSE;
}
Catch(ElementParser::Exception::ParseError)
{
- LogError("Failed to parse config.xml file");
+ _E("Failed to parse config.xml file");
return FALSE;
}
Catch(DPL::ZipInput::Exception::SeekFileFailed)
{
- LogError("Failed to seek widget archive - corrupted package?");
+ _E("Failed to seek widget archive - corrupted package?");
return FALSE;
}
}
Catch(DPL::ZipInput::Exception::OpenFileFailed)
{
- LogDebug("This web app is hybrid web app");
+ _D("This web app is hybrid web app");
std::string hybrid_icon = "res/wgt/" + icon_name;
iconFile.reset(zipFile->OpenFile(hybrid_icon));
}
}
Catch(DPL::ZipInput::Exception::OpenFailed)
{
- LogDebug("Failed to open widget package");
+ _D("Failed to open widget package");
return NULL;
}
Catch(DPL::ZipInput::Exception::OpenFileFailed)
{
- LogDebug("Not found icon file " << icon_name);
+ _D("Not found icon file %s", icon_name.c_str());
return NULL;
}
}
pkg_detail_info->privilege_list = NULL;
FOREACH(it, configInfo.featuresList) {
std::string featureInfo = DPL::ToUTF8String(it->name);
- LogDebug("privilege : " << featureInfo);
+ _D("privilege : %s", featureInfo.c_str());
int length = featureInfo.size();
char *privilege = (char*) calloc(1, (sizeof(char) * (length + 1)));
snprintf(privilege, length + 1, "%s", featureInfo.c_str());
char* icon_buf = getIcon(widget_path, configInfo, pkg_detail_info->icon_size);
if (icon_buf) {
- LogDebug("icon size : " << pkg_detail_info->icon_size);
+ _D("icon size : %d", pkg_detail_info->icon_size);
pkg_detail_info->icon_buf = icon_buf;
} else {
- LogDebug("No icon");
+ _D("No icon");
pkg_detail_info->icon_size = 0;
pkg_detail_info->icon_buf = NULL;
}
const char * pkg_path,
package_manager_pkg_detail_info_t * pkg_detail_info)
{
- LogDebug("pkg_plugin_get_app_detail_info_from_package() is called");
+ _D("pkg_plugin_get_app_detail_info_from_package() is called");
return getWidgetDetailInfoFromPackage(pkg_path, pkg_detail_info);
}
pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
{
- LogDebug("pkgmgr_client_check_pkginfo_from_file() is called");
+ _D("pkgmgr_client_check_pkginfo_from_file() is called");
package_manager_pkg_detail_info_t *pkg_detail_info;
pkg_detail_info = (package_manager_pkg_detail_info_t*)malloc(
sizeof(package_manager_pkg_detail_info_t));
int ret = getWidgetDetailInfoFromPackage(pkg_path, pkg_detail_info);
if (FALSE == ret) {
- LogError("Failed to get package detail info ");
+ _E("Failed to get package detail info ");
return NULL;
}
return reinterpret_cast<pkgmgr_info*>(pkg_detail_info);
* @brief
*/
-#include <dpl/log/log.h>
#include <pkgmgr_installer.h>
#include <pkg-manager/pkgmgr_signal.h>
+#include <installer_log.h>
namespace PackageManager {
PkgmgrSignal::PkgmgrSignal() :
bool PkgmgrSignal::initialize(int argc, char* argv[])
{
if (m_handle) {
- LogDebug("Release already allocated pkgmgr handle");
+ _D("Release already allocated pkgmgr handle");
pkgmgr_installer_free(m_handle);
m_handle = NULL;
}
m_handle = pkgmgr_installer_new();
if (!m_handle) {
- LogError("Fail to get pkgmgr installer handle");
+ _E("Fail to get pkgmgr installer handle");
return false;
}
m_reqType != PKGMGR_REQ_UNINSTALL &&
m_reqType != PKGMGR_REQ_REINSTALL)
{
- LogError("Fail to get request type of pkgmgr");
+ _E("Fail to get request type of pkgmgr");
pkgmgr_installer_free(m_handle);
m_handle = NULL;
return false;
m_callerId = callerId;
} else {
- LogError("Fail to get information of pkgmgr's request");
+ _E("Fail to get information of pkgmgr's request");
pkgmgr_installer_free(m_handle);
m_handle = NULL;
return false;
bool PkgmgrSignal::deinitialize()
{
if (!m_initialized) {
- LogError("PkgmgrSingal not yet intialized");
+ _E("PkgmgrSingal not yet intialized");
return false;
}
bool PkgmgrSignal::setPkgname(const std::string& name)
{
if (!m_initialized) {
- LogError("PkgmgrSingal not yet intialized");
+ _E("PkgmgrSingal not yet intialized");
return false;
}
if (name.empty()) {
- LogError("name is empty");
+ _E("name is empty");
return false;
}
m_pkgname = name;
- LogDebug("Success to set tizen package name: " << m_pkgname);
+ _D("Success to set tizen package name: %s", m_pkgname.c_str());
return true;
}
const std::string& value) const
{
if (!m_initialized) {
- LogError("PkgmgrSingal not yet intialized");
+ _E("PkgmgrSingal not yet intialized");
return false;
}
if (key.empty() || value.empty()) {
- LogDebug("key or value is empty");
+ _D("key or value is empty");
return false;
}
if (m_handle == NULL || m_type.empty()) {
- LogError("Some data of PkgmgrSignal is empty");
+ _E("Some data of PkgmgrSignal is empty");
return false;
}
m_handle, m_type.c_str(), m_pkgname.c_str(),
key.c_str(), value.c_str()))
{
- LogError("Fail to send pkgmgr signal");
+ _E("Fail to send pkgmgr signal");
return false;
}
- LogDebug("Success to send pkgmgr signal: " << key <<
- " - " << value);
+ _D("Success to send pkgmgr signal: %s - %s", key.c_str(), value.c_str());
return true;
}
std::string PkgmgrSignal::getPkgname() const
{
if (!m_initialized) {
- LogError("PkgmgrSingal not yet intialized");
+ _E("PkgmgrSingal not yet intialized");
}
return m_pkgname;
int PkgmgrSignal::getRequestedType() const
{
if (!m_initialized) {
- LogError("PkgmgrSingal not yet intialized");
+ _E("PkgmgrSingal not yet intialized");
}
return m_reqType;
std::string PkgmgrSignal::getCallerId() const
{
if (!m_initialized) {
- LogError("PkgmgrSingal not yet intialized");
+ _E("PkgmgrSingal not yet intialized");
}
return m_callerId;
*/
#include <installer_callbacks_translate.h>
-#include <dpl/log/log.h>
+#include <dpl/assert.h>
+#include <installer_log.h>
namespace InstallerCallbacksTranslate {
// Callback
apiStr->status_callback(tizenId, errorStatus, apiStr->userdata);
} else {
- LogDebug("installFinishedCallback: No callback");
+ _D("installFinishedCallback: No callback");
}
}
// Callback
apiStr->status_callback(tizenId, errorStatus, apiStr->userdata);
} else {
- LogDebug("uninstallFinishedCallback: No callback");
+ _D("uninstallFinishedCallback: No callback");
}
}
apiStr->statusCallback(errorStatus, apiStr->userdata);
} else {
- LogDebug("PluginInstallFinishedCallback: No callback");
+ _D("PluginInstallFinishedCallback: No callback");
}
delete apiStr;
if (apiStr->progress_callback) {
//CALLBACK EXEC
- LogPedantic("Entered " << percent << "% " << description);
+ _D("Entered %2.0f% %s", percent, description.c_str());
apiStr->progress_callback(static_cast<float>(percent),
description.c_str(),
apiStr->userdata);
} else {
- LogPedantic("installProgressCallback: ignoring NULL callback pointer");
+ _D("installProgressCallback: ignoring NULL callback pointer");
}
}
} //namespace
* @version 1.0
*/
#include <language_subtag_rst_tree.h>
-#include <dpl/log/log.h>
#include <dpl/db/orm.h>
#include <dpl/string.h>
#include <dpl/scope_guard.h>
#include <vector>
#include <ctype.h>
#include <dpl/singleton_impl.h>
+#include <installer_log.h>
+
IMPLEMENT_SINGLETON(LanguageSubtagRstTree)
namespace I18nDAOReadOnly = I18n::DB::I18nDAOReadOnly;
#define TEST_LANG(str, cond) \
if (LanguageSubtagRstTreeSingleton::Instance(). \
ValidateLanguageTag(str) == cond) { \
- LogDebug("Good validate status for lang: " << str); \
+ _D("Good validate status for lang: %s", str); \
} else { \
- LogError("Wrong validate status for lang: " << str \
- << ", should be " << cond); \
+ _E("Wrong validate status for lang: %s, should be %d", str, cond); \
}
void LanguageSubtagRstTree::Initialize()
#include <unistd.h>
#include "plugin_utils.h"
#include <dpl/exception.h>
-#include <dpl/log/log.h>
#include <dpl/wrt-dao-ro/global_config.h>
#include <sys/file.h>
+#include <installer_log.h>
using namespace WrtDB;
int ret = 0;
- LogDebug("Try to lock for plugins installation.");
+ _D("Try to lock for plugins installation.");
s_plugin_install_lock_fd =
open(PLUGIN_INSTALL_LOCK_FILE, O_RDONLY | O_CREAT, 0666);
if (s_plugin_install_lock_fd == -1) {
- LogError("Lock file open failed!");
+ _E("Lock file open failed!");
return false;
}
ret = flock(s_plugin_install_lock_fd, LOCK_EX); //lock with waiting
if (ret == -1) {
- LogError("Lock failed!");
+ _E("Lock failed!");
close(s_plugin_install_lock_fd);
s_plugin_install_lock_fd = -1;
bool unlockPluginInstallation(bool isPreload)
{
- LogDebug("Unlock for plugins installation.");
+ _D("Unlock for plugins installation.");
if (isPreload) {
fprintf(stderr, "Skip plugin unlock.. \n");
return true;
ret = flock(s_plugin_install_lock_fd, LOCK_UN); //unlock
if (ret == -1) {
- LogError("Unlock failed!");
+ _E("Unlock failed!");
}
close(s_plugin_install_lock_fd);
return true;
} else {
- LogError("Lock file was not created!");
+ _E("Lock file was not created!");
}
return false;
case FileState::FILE_NOT_EXISTS:
return false;
default:
- LogWarning("Opening installation request file failed");
+ _W("Opening installation request file failed");
return false;
}
}
#include <dirent.h>
#include <sys/resource.h>
-#include <dpl/log/log.h>
#include <dpl/optional_typedefs.h>
#include <dpl/wrt-dao-ro/global_config.h>
#include <dpl/wrt-dao-ro/config_parser_data.h>
#include <pkg-manager/pkgmgr_signal_dummy.h>
#include <pkg-manager/pkgmgr_signal.h>
+#include <installer_log.h>
using namespace WrtDB;
m_startupPluginInstallation(false)
{
Touch();
- LogDebug("App Created");
+ _D("App Created");
}
WrtInstaller::~WrtInstaller()
{
- LogDebug("App Finished");
+ _D("App Finished");
}
int WrtInstaller::getReturnStatus() const
void WrtInstaller::OnStop()
{
- LogDebug("Stopping Dummy Client");
+ _D("Stopping Dummy Client");
}
void WrtInstaller::OnCreate()
{
- LogDebug("Creating DummyClient");
+ _D("Creating DummyClient");
showArguments();
AddStep(&WrtInstaller::initStep);
if (!m_startupPluginInstallation) {
AddStep(&WrtInstaller::installPluginsStep);
} else {
- LogDebug("Plugin installation alredy started");
+ _D("Plugin installation alredy started");
}
} else if (arg == "-i" || arg == "--install") {
if (m_argc != 3) {
struct stat info;
if (-1 != stat(m_argv[2], &info) && S_ISDIR(info.st_mode)) {
- LogDebug("Installing package directly from directory");
+ _D("Installing package directly from directory");
m_installMode.extension = InstallMode::ExtensionType::DIR;
} else {
- LogDebug("Installing from regular location");
+ _D("Installing from regular location");
m_installMode.extension = InstallMode::ExtensionType::WGT;
}
m_packagePath = m_argv[2];
AddStep(&WrtInstaller::installStep);
} else if (arg == "-ip" || arg == "--install-preload") {
- LogDebug("Install preload web app");
+ _D("Install preload web app");
if (m_argc != 3) {
return showHelpAndQuit();
}
m_installMode.rootPath = InstallMode::RootPath::RO;
AddStep(&WrtInstaller::installStep);
} else if (arg == "-ipw" || arg == "--install-preload-writable") {
- LogDebug("Install preload web application to writable storage");
+ _D("Install preload web application to writable storage");
if (m_argc != 3) {
return showHelpAndQuit();
}
AddStep(&WrtInstaller::installStep);
} else if (arg == "-c" || arg == "--csc-update") {
// "path=/opt/system/csc/Ozq2iEG15R-2.0.0-arm.wgt:op=install:removable=true"
- LogDebug("Install & uninstall by csc configuration");
+ _D("Install & uninstall by csc configuration");
if (m_argc != 3) {
return showHelpAndQuit();
}
}
if (it->second == CSCConfiguration::VALUE_INSTALL) {
- LogDebug("operation = " << it->second);
+ _D("operation = %s", it->second.c_str());
m_installMode.extension = InstallMode::ExtensionType::WGT;
it = m_CSCconfigurationMap.find(CSCConfiguration::KEY_PATH);
if (it == m_CSCconfigurationMap.end()) {
? false : true;
AddStep(&WrtInstaller::installStep);
- LogDebug("path = " << m_packagePath);
+ _D("path = %s", m_packagePath.c_str());
} else if (it->second == CSCConfiguration::VALUE_UNINSTALL) {
- LogDebug("operation = " << it->second);
+ _D("operation = %s", it->second.c_str());
// uninstall command isn't confirmed yet
it = m_CSCconfigurationMap.find(CSCConfiguration::KEY_PATH);
if (it == m_CSCconfigurationMap.end()) {
}
m_packagePath = it->second;
AddStep(&WrtInstaller::unistallWgtFileStep);
- LogDebug("operation = uninstall");
- LogDebug("path = " << m_packagePath);
+ _D("operation = uninstall");
+ _D("path = %s", m_packagePath.c_str());
} else {
- LogError("Unknown operation : " << it->second);
- LogDebug("operation = " << it->second);
+ _E("Unknown operation : %s", it->second.c_str());
+ _D("operation = %s", it->second.c_str());
return showHelpAndQuit();
}
} else if (arg == "-un" || arg == "--uninstall-name") {
if (m_argc != 3) {
return showHelpAndQuit();
}
- LogDebug("Installing package directly from directory");
+ _D("Installing package directly from directory");
m_installMode.command = InstallMode::Command::REINSTALL;
m_installMode.extension = InstallMode::ExtensionType::DIR;
m_packagePath = m_argv[2];
m_packagePath = m_argv[4];
struct stat info;
if (-1 != stat(m_argv[4], &info) && S_ISDIR(info.st_mode)) {
- LogDebug("Installing package directly from directory");
+ _D("Installing package directly from directory");
m_installMode.extension = InstallMode::ExtensionType::DIR;
} else {
- LogDebug("Installing from regular location");
+ _D("Installing from regular location");
m_installMode.extension = InstallMode::ExtensionType::WGT;
}
AddStep(&WrtInstaller::installStep);
if (0 == pkgmgrinfo_pkginfo_get_pkginfo(m_name.c_str(), &handle)) {
if (0 > pkgmgrinfo_pkginfo_is_system(handle, &system_app)) {
- LogError("Can't get package information : " << m_name);
+ _E("Can't get package information : %s", m_name.c_str());
}
if (0 > pkgmgrinfo_pkginfo_is_update(handle, &update)) {
- LogError("Can't get package information about update : "
- << m_name);
+ _E("Can't get package information about update : %s", m_name.c_str());
}
}
- LogDebug("system app : " << system_app);
- LogDebug("update : " << update);
+ _D("system app : %d", system_app);
+ _D("update : %d", update);
if (system_app && update) {
AddStep(&WrtInstaller::removeUpdateStep);
AddStep(&WrtInstaller::installStep);
break;
default:
- LogDebug("Not available type");
+ _D("Not available type");
break;
}
}
void WrtInstaller::OnReset(bundle* /*b*/)
{
- LogDebug("OnReset");
+ _D("OnReset");
}
void WrtInstaller::OnTerminate()
{
- LogDebug("Wrt Shutdown now");
+ _D("Wrt Shutdown now");
PluginUtils::unlockPluginInstallation(
m_installMode.installTime == InstallMode::InstallTime::PRELOAD);
if (m_initialized) {
fprintf(stderr,
"===========================================================\n");
// for dlog
- LogDebug("===========================================================");
- LogDebug("# wrt-installer #");
- LogDebug("# argc " << m_argc);
+ _D("===========================================================");
+ _D("# wrt-installer #");
+ _D("# argc %d", m_argc);
for (int i = 0; i < m_argc; i++) {
- LogDebug("# argv[" << i << "] = " << m_argv[i]);
+ _D("# argv[%d] = %s", i, m_argv[i]);
}
- LogDebug("===========================================================");
+ _D("===========================================================");
}
void WrtInstaller::OnEventReceived(const WRTInstallerNS::QuitEvent& /*event*/)
{
- LogDebug("Quiting");
+ _D("Quiting");
if (m_initialized) {
- LogDebug("Wrt Shutdown now");
+ _D("Wrt Shutdown now");
SwitchToStep(&WrtInstaller::shutdownStep);
DPL::Event::ControllerEventHandler<WRTInstallerNS::NextStepEvent>::
PostEvent(
WRTInstallerNS::NextStepEvent());
} else {
- LogDebug("Quiting application");
+ _D("Quiting application");
return Quit();
}
}
void WrtInstaller::OnEventReceived(
const WRTInstallerNS::NextStepEvent& /*event*/)
{
- LogDebug("Executing next step");
+ _D("Executing next step");
NextStep();
}
void WrtInstaller::installStep()
{
- LogDebug("Installing widget ...");
+ _D("Installing widget ...");
std::unique_ptr<char, free_deleter> packagePath(canonicalize_file_name(
m_packagePath.c_str()));
void WrtInstaller::installPluginsStep()
{
- LogDebug("Installing plugins ...");
+ _D("Installing plugins ...");
fprintf(stderr, "Installing plugins ...\n");
if (m_startupPluginInstallation) {
- LogDebug("Plugin installation started because new plugin package found");
+ _D("Plugin installation started because new plugin package found");
} else if (!PluginUtils::lockPluginInstallation(
m_installMode.installTime == InstallMode::InstallTime::PRELOAD))
{
- LogError("Failed to open plugin installation lock file"
+ _E("Failed to open plugin installation lock file"
" Plugins are currently installed by other process");
staticWrtPluginInstallationCallback(WRT_INSTALLER_ERROR_PLUGIN_INSTALLATION_FAILED,
this);
return;
}
- LogDebug("Plugin DIRECTORY IS" << PLUGIN_PATH);
+ _D("Plugin DIRECTORY IS %s", PLUGIN_PATH.c_str());
std::list<std::string> pluginsPaths;
struct dirent libdir;
struct stat tmp;
if (stat(path.c_str(), &tmp) == -1) {
- LogError("Failed to open file" << path);
+ _E("Failed to open file %s", path.c_str());
continue;
}
if (!S_ISDIR(tmp.st_mode)) {
- LogError("Not a directory" << path);
+ _E("Not a directory %s", path.c_str());
continue;
}
}
if (return_code != 0 || errno != 0) {
- LogError("readdir_r() failed with " << DPL::GetErrnoString());
+ _E("readdir_r() failed with %s", DPL::GetErrnoString().c_str());
}
//set nb of plugins to install
//this value indicate how many callbacks are expected
m_numPluginsToInstall = pluginsPaths.size();
- LogDebug("Plugins to install: " << m_numPluginsToInstall);
+ _D("Plugins to install: %d", m_numPluginsToInstall);
m_pluginsPaths = pluginsPaths;
m_totalPlugins = m_numPluginsToInstall;
::PostEvent(WRTInstallerNS::InstallPluginEvent());
if (-1 == TEMP_FAILURE_RETRY(closedir(dir))) {
- LogError("Failed to close dir: " << PLUGIN_PATH << " with error: "
- << DPL::GetErrnoString());
+ _E("Failed to close dir: %s with error: %s", PLUGIN_PATH.c_str(), DPL::GetErrnoString().c_str());
}
}
void WrtInstaller::uninstallPkgNameStep()
{
- LogDebug("Uninstalling widget ...");
- LogDebug("Package name : " << m_name);
+ _D("Uninstalling widget ...");
+ _D("Package name : %s", m_name.c_str());
wrt_uninstall_widget(m_name.c_str(), this,
&staticWrtStatusCallback,
void WrtInstaller::removeUpdateStep()
{
- LogDebug("This web app need to initialize preload app");
- LogDebug("Package name : " << m_name);
+ _D("This web app need to initialize preload app");
+ _D("Package name : %s", m_name.c_str());
wrt_uninstall_widget(m_name.c_str(), this,
&staticWrtInitializeToPreloadCallback,
void WrtInstaller::unistallWgtFileStep()
{
- LogDebug("Uninstalling widget ...");
+ _D("Uninstalling widget ...");
Try {
// Parse config
DPL::OptionalString pkgId = configInfo.tizenPkgId;
if (!pkgId.IsNull()) {
- LogDebug("Pkgid from packagePath : " << pkgId);
+ _D("Pkgid from packagePath : %ls", (*pkgId).c_str());
wrt_uninstall_widget(
DPL::ToUTF8String(*pkgId).c_str(), this, &staticWrtStatusCallback,
!m_installByPkgmgr ? &staticWrtUninstallProgressCallback
: NULL,
pkgmgrSignalInterface);
} else {
- LogError("Fail to uninstalling widget... ");
+ _E("Fail to uninstalling widget... ");
m_returnStatus = -1;
DPL::Event::ControllerEventHandler<WRTInstallerNS::QuitEvent>::
PostEvent(
}
Catch(DPL::ZipInput::Exception::OpenFailed)
{
- LogError("Failed to open widget package");
+ _E("Failed to open widget package");
printf("failed: widget package does not exist\n");
m_returnStatus = -1;
DPL::Event::ControllerEventHandler<WRTInstallerNS::QuitEvent>::
Catch(DPL::ZipInput::Exception::OpenFileFailed)
{
printf("failed: widget config file does not exist\n");
- LogError("Failed to open config.xml file");
+ _E("Failed to open config.xml file");
m_returnStatus = -1;
DPL::Event::ControllerEventHandler<WRTInstallerNS::QuitEvent>::
PostEvent(
Catch(ElementParser::Exception::ParseError)
{
printf("failed: can not parse config file\n");
- LogError("Failed to parse config.xml file");
+ _E("Failed to parse config.xml file");
m_returnStatus = -1;
DPL::Event::ControllerEventHandler<WRTInstallerNS::QuitEvent>::
PostEvent(
void WrtInstaller::shutdownStep()
{
- LogDebug("Closing Wrt connection ...");
+ _D("Closing Wrt connection ...");
if (m_initialized) {
wrt_installer_shutdown();
m_initialized = false;
Assert(This);
if (status == WRT_SUCCESS) {
- LogDebug("Init succesfull");
+ _D("Init succesfull");
This->m_initialized = true;
This->m_returnStatus = 0;
This->DPL::Event::ControllerEventHandler<WRTInstallerNS::NextStepEvent>
::PostEvent(WRTInstallerNS::NextStepEvent());
} else {
- LogError("Init unsuccesfull");
+ _E("Init unsuccesfull");
This->m_returnStatus = -1;
This->DPL::Event::ControllerEventHandler<WRTInstallerNS::QuitEvent>::
PostEvent(
if (WRT_SUCCESS != status) {
// Failure
- LogError("Step failed");
+ _E("Step failed");
This->m_returnStatus = 1;
This->showErrorMsg(status, tizenId, printMsg);
if (WRT_SUCCESS != status) {
// Failure
- LogError("Step failed");
+ _E("Step failed");
This->m_returnStatus = status;
This->showErrorMsg(status, tizenId, printMsg);
"## wrt-installer : %s %s was successful.\n",
tizenId.c_str(),
printMsg.c_str());
- LogDebug("Status succesfull");
+ _D("Status succesfull");
This->m_returnStatus = 0;
resultMsg += L" : " + DPL::FromUTF8String(PKGMGR_END_SUCCESS);
if (WRT_SUCCESS != status) {
// Failure
- LogError("Step failed");
+ _E("Step failed");
This->m_returnStatus = status;
This->DPL::Event::ControllerEventHandler<WRTInstallerNS::QuitEvent>
"## wrt-installer : %s %s was successful.\n",
tizenId.c_str(),
printMsg.c_str());
- LogDebug("Status succesfull");
+ _D("Status succesfull");
This->m_returnStatus = 0;
resultMsg += L" : " + DPL::FromUTF8String(PKGMGR_END_SUCCESS);
if (This->m_installMode.installTime == InstallMode::InstallTime::PRELOAD &&
!This->m_packagePath.empty())
{
- LogDebug("This widget is preloaded so it will be removed : "
- << This->m_packagePath);
+ _D("This widget is preloaded so it will be removed : %s", This->m_packagePath.c_str());
if (!WrtUtilRemove(This->m_packagePath)) {
- LogError("Failed to remove " << This->m_packagePath);
+ _E("Failed to remove %s", This->m_packagePath.c_str());
}
}
delete data;
This->m_numPluginsToInstall--;
- LogDebug("Plugins to install: " << This->m_numPluginsToInstall);
+ _D("Plugins to install: %d", This->m_numPluginsToInstall);
if (This->m_numPluginsToInstall < 1) {
- LogDebug("All plugins installation completed");
+ _D("All plugins installation completed");
fprintf(stderr, "All plugins installation completed.\n");
//remove installation request
if (!PluginUtils::removeInstallationRequiredFlag()) {
- LogDebug("Failed to remove file initializing plugin installation");
+ _D("Failed to remove file initializing plugin installation");
}
//remove lock file
if (!PluginUtils::unlockPluginInstallation(
This->m_installMode.installTime == InstallMode::InstallTime::PRELOAD))
{
- LogDebug("Failed to remove installation lock");
+ _D("Failed to remove installation lock");
}
This->DPL::Event::ControllerEventHandler<WRTInstallerNS::NextStepEvent>
fprintf(stderr,
"## wrt-installer : plugin installation successfull [%s]\n",
path.c_str());
- LogDebug("One plugin Installation succesfull: " << path);
+ _D("One plugin Installation succesfull: %s", path.c_str());
return;
}
// Failure
- LogWarning("One of the plugins installation failed!: " << path);
+ _W("One of the plugins installation failed!: %s", path.c_str());
switch (status) {
case WRT_INSTALLER_ERROR_PLUGIN_INSTALLATION_FAILED:
- LogError("failed: plugin installation failed\n");
+ _E("failed: plugin installation failed\n");
break;
case WRT_INSTALLER_ERROR_UNKNOWN:
- LogError("failed: unknown error\n");
+ _E("failed: unknown error\n");
break;
default:
std::string path = std::string(data->pluginPath);
- LogDebug("Plugin Installation: " << path <<
- " progress: " << percent <<
- "description " << description);
+ _D("Plugin Installation: %s progress: %2.0f description: %s", path.c_str(), percent, description);
}
void WrtInstaller::staticWrtInstallProgressCallback(float percent,
void* /*userdata*/)
{
//WrtInstaller *This = static_cast<WrtInstaller*>(userdata);
- LogDebug(" progress: " << percent <<
- " description: " << description);
+ _D(" progress: %2.0f description: %s", percent, description);
}
void WrtInstaller::staticWrtUninstallProgressCallback(float percent,
const char* description,
void* /*userdata*/)
{
//WrtInstaller *This = static_cast<WrtInstaller*>(userdata);
- LogDebug(" progress: " << percent <<
- " description: " << description);
+ _D(" progress: %2.0f description: %s", percent, description);
}
void WrtInstaller::showResultCallback(void *data, Evas_Object* /*obj*/,
void WrtInstaller::installNewPlugins()
{
- LogDebug("Install new plugins");
+ _D("Install new plugins");
if (!PluginUtils::lockPluginInstallation(
m_installMode.installTime == InstallMode::InstallTime::PRELOAD))
{
- LogDebug("Lock NOT created");
+ _D("Lock NOT created");
return;
}
if (!PluginUtils::checkPluginInstallationRequired()) {
- LogDebug("Plugin installation not required");
+ _D("Plugin installation not required");
PluginUtils::unlockPluginInstallation(
m_installMode.installTime == InstallMode::InstallTime::PRELOAD);
return;
{
// path=/opt/system/csc/Ozq2iEG15R-2.0.0-arm.wgt:op=install:removable=true
// parsing CSC configuration string
- LogDebug("parseConfiguration");
+ _D("parseConfiguration");
CSCConfiguration::dataMap result;
if (str.empty()) {
- LogDebug("Input argument is empty");
+ _D("Input argument is empty");
return result;
}
// Check and re-set the file open limitation
struct rlimit rlim;
if (getrlimit(RLIMIT_NOFILE, &rlim) != -1) {
- LogDebug("RLIMIT_NOFILE sft(" << rlim.rlim_cur << ")");
- LogDebug("RLIMIT_NOFILE hrd(" << rlim.rlim_max << ")");
+ _D("RLIMIT_NOFILE sft(%d)", rlim.rlim_cur);
+ _D("RLIMIT_NOFILE hrd(%d)", rlim.rlim_max);
if (rlim.rlim_cur < NOFILE_CNT_FOR_INSTALLER) {
rlim.rlim_cur = NOFILE_CNT_FOR_INSTALLER;
rlim.rlim_max = NOFILE_CNT_FOR_INSTALLER;
if (setrlimit(RLIMIT_NOFILE, &rlim) == -1) {
- LogError("setrlimit is fail!!");
+ _E("setrlimit is fail!!");
}
}
} else {
- LogError("getrlimit is fail!!");
+ _E("getrlimit is fail!!");
}
WrtInstaller app(argc, argv);
int ret = app.Exec();
- LogDebug("App returned: " << ret);
+ _D("App returned: %d", ret);
ret = app.getReturnStatus();
- LogDebug("WrtInstaller returned: " << ret);
+ _D("WrtInstaller returned: %d", ret);
return ret;
}
UNHANDLED_EXCEPTION_HANDLER_END
#include <sys/stat.h>
#include <unistd.h>
#include <dpl/exception.h>
-#include <dpl/log/log.h>
#include <dpl/assert.h>
#include <dpl/semaphore.h>
#include <dpl/sstream.h>
#include <vcore/VCore.h>
#include <installer_main_thread.h>
#include <wrt_install_mode.h>
+#include <installer_log.h>
using namespace WrtDB;
if (0 == stat(path.c_str(), &st) && S_ISDIR(st.st_mode)) {
return true;
}
- LogError("Cannot access directory [ " << path << " ]");
+ _E("Cannot access directory [ %s ]", path.c_str());
return false;
}
WrtInstallerInitCallback callback)
{
try {
- LogDebug("[WRT-API] INITIALIZING WRT INSTALLER...");
- LogDebug("[WRT-API] BUILD: " << __TIMESTAMP__);
+ _D("[WRT-API] INITIALIZING WRT INSTALLER...");
+ _D("[WRT-API] BUILD: %s", __TIMESTAMP__);
// Touch InstallerController Singleton
InstallerMainThreadSingleton::Instance().TouchArchitecture();
InstallerMainThreadSingleton::Instance().AttachDatabases();
- LogDebug("Prepare libxml2 to work in multithreaded program.");
+ _D("Prepare libxml2 to work in multithreaded program.");
xmlInitParser();
// // Initialize Language Subtag registry
InitializeEvent());
if (callback) {
- LogDebug("[WRT-API] WRT INSTALLER INITIALIZATION CALLBACK");
+ _D("[WRT-API] WRT INSTALLER INITIALIZATION CALLBACK");
callback(WRT_SUCCESS, userdata);
}
} catch (const DPL::Exception& ex) {
- LogError("Internal Error during Init:");
+ _E("Internal Error during Init:");
DPL::Exception::DisplayKnownException(ex);
if (callback) {
callback(WRT_INSTALLER_ERROR_FATAL_ERROR, userdata);
void wrt_installer_shutdown()
{
try {
- LogDebug("[WRT-API] DEINITIALIZING WRT INSTALLER...");
+ _D("[WRT-API] DEINITIALIZING WRT INSTALLER...");
// Installer termination
CONTROLLER_POST_SYNC_EVENT(
ValidationCore::VCoreDeinit();
// Global deinit check
- LogDebug("Cleanup libxml2 global values.");
+ _D("Cleanup libxml2 global values.");
xmlCleanupParser();
} catch (const DPL::Exception& ex) {
- LogError("Internal Error during Shutdown:");
+ _E("Internal Error during Shutdown:");
DPL::Exception::DisplayKnownException(ex);
}
}
DPL::Log::LogSystemSingleton::Instance().AddProvider(oldStyleProvider);
}
- LogDebug("[WRT-API] INSTALL WIDGET: " << path);
+ _D("[WRT-API] INSTALL WIDGET: %s", path);
// Post installation event
CONTROLLER_POST_EVENT(
Logic::InstallerController,
UNHANDLED_EXCEPTION_HANDLER_BEGIN
{
std::string tizenAppid(tzAppid);
- LogDebug("[WRT-API] UNINSTALL WIDGET: " << tizenAppid);
+ _D("[WRT-API] UNINSTALL WIDGET: %s", tizenAppid.c_str());
// Post uninstallation event
CONTROLLER_POST_EVENT(
Logic::InstallerController,
{
UNHANDLED_EXCEPTION_HANDLER_BEGIN
{
- LogDebug("[WRT-API] INSTALL PLUGIN: " << pluginDir);
+ _D("[WRT-API] INSTALL PLUGIN: %s", pluginDir);
//Private data for status callback
//Resource is free in pluginInstallFinishedCallback
InstallerCallbacksTranslate::PluginStatusCallbackStruct*
#include "InstallerWrapper.h"
-#include <dpl/log/log.h>
+#include <installer_log.h>
#include <cstdio>
size_t startIndex = src.find(INSTALLER_MESSSGE_START);
if (startIndex == std::string::npos)
{
- LogWarning("Installer message can not be found");
+ _W("Installer message can not be found");
return std::string();
}
size_t newLineIndex = src.find("\n", startIndex);
{
msg += buffer;
}
- LogDebug(msg);
+ _D("%s", msg.c_str());
auto err = pclose(filehandle);
if (!WIFEXITED(err)) {
return OtherError;
int nr = sscanf(line.c_str(), INSTALLER_MESSAGE_ID_LINE_FAIL.c_str(), id);
if (1 != nr)
{
- LogWarning("Can not read widget ID from message: " << line);
+ _W("Can not read widget ID from message: %s", line.c_str());
delete[] id;
return OtherError;
}
if (1 != nr)
{
- LogWarning("Can not read widget ID from message: " << line);
+ _W("Can not read widget ID from message: %s", line.c_str());
delete[] id;
return OtherError;
}
bool uninstall(const std::string& tizenId)
{
std::string cmd = uninstallCmd + tizenId + " > /dev/null 2>/dev/null";
- LogDebug("executing: " << cmd);
+ _D("executing: %s", cmd.c_str());
return (system(cmd.c_str()) == EXIT_SUCCESS);
}
#include <libxml/parser.h>
#include <libxml/tree.h>
-#include <dpl/log/log.h>
+#include <installer_log.h>
//TODO: This file reads manifest file. This functionality is familiar with writing
// in wrt-installer but reading ws not necessary there.
#include <dpl/test/test_runner.h>
#include <InstallerWrapper.h>
#include <ManifestFile.h>
-#include <dpl/log/log.h>
+#include <installer_log.h>
using namespace InstallerWrapper;
Try
{
- LogDebug("Package " << mf.getValueByXpath("/p:manifest/@package"));
+ _D("Package %s", mf.getValueByXpath("/p:manifest/@package").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/@package")
== tizenId.substr(0,10));
- LogDebug("type " << mf.getValueByXpath("/p:manifest/@type"));
+ _D("type %s", mf.getValueByXpath("/p:manifest/@type").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/@type")
== "wgt");
- LogDebug("version " << mf.getValueByXpath("/p:manifest/@version"));
+ _D("version %s", mf.getValueByXpath("/p:manifest/@version").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/@version")
== "1.0");
- LogDebug("label " << mf.getValueByXpath("/p:manifest/p:label"));
+ _D("label %s", mf.getValueByXpath("/p:manifest/p:label").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/p:label")
== "Manifest Example");
- LogDebug("email " << mf.getValueByXpath("/p:manifest/p:author/@email"));
+ _D("email %s", mf.getValueByXpath("/p:manifest/p:author/@email").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/p:author/@email")
== "manifest@misc.test.create.desktop.com");
- LogDebug("href " << mf.getValueByXpath("/p:manifest/p:author/@href"));
+ _D("href %s", mf.getValueByXpath("/p:manifest/p:author/@href").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/p:author/@href")
== "http://misc.test.create.desktop.com");
- LogDebug("author " << mf.getValueByXpath("/p:manifest/p:author"));
+ _D("author %s", mf.getValueByXpath("/p:manifest/p:author").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/p:author")
== "Manifest");
- LogDebug("appid " << mf.getValueByXpath("/p:manifest/p:ui-application/@appid"));
+ _D("appid %s", mf.getValueByXpath("/p:manifest/p:ui-application/@appid").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/p:ui-application/@appid")
== tizenId);
- LogDebug("nodisplay " << mf.getValueByXpath("/p:manifest/p:ui-application/@nodisplay"));
+ _D("nodisplay %s", mf.getValueByXpath("/p:manifest/p:ui-application/@nodisplay").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/p:ui-application/@nodisplay")
== "false");
- LogDebug("type " << mf.getValueByXpath("/p:manifest/p:ui-application/@type"));
+ _D("type %s", mf.getValueByXpath("/p:manifest/p:ui-application/@type").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/p:ui-application/@type")
== "webapp");
- LogDebug("extraid " << mf.getValueByXpath("/p:manifest/p:ui-application/@extraid"));
+ _D("extraid %s", mf.getValueByXpath("/p:manifest/p:ui-application/@extraid").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/p:ui-application/@extraid")
== "http://test.samsung.com/widget/manifestTest");
- LogDebug("taskmanage " << mf.getValueByXpath("/p:manifest/p:ui-application/@taskmanage"));
+ _D("taskmanage %s", mf.getValueByXpath("/p:manifest/p:ui-application/@taskmanage").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/p:ui-application/@taskmanage")
== "true");
- LogDebug("icon " << mf.getValueByXpath("/p:manifest/p:ui-application/p:icon"));
+ _D("icon %s", mf.getValueByXpath("/p:manifest/p:ui-application/p:icon").c_str());
RUNNER_ASSERT(mf.getValueByXpath("/p:manifest/p:ui-application/p:icon")
== (tizenId + ".png"));
#include <string>
#include <algorithm>
-#include <dpl/log/log.h>
#include <dpl/test/test_runner.h>
#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
#include <InstallerWrapper.h>
+#include <installer_log.h>
using namespace InstallerWrapper;
dao.getAppControlList(appcontrolList);
uninstall(tizenId);
- LogDebug("Actual size" << appcontrolList.size());
+ _D("Actual size %d", appcontrolList.size());
RUNNER_ASSERT_MSG(appcontrolList.size() == 4, "Incorrect list size");
WrtDB::WidgetAppControl s;
s.src = DPL::FromUTF8String("edit1.html");
#include <string>
#include <dpl/test/test_runner.h>
-#include <dpl/log/log.h>
#include <dpl/wrt-dao-ro/plugin_dao_read_only.h>
#include <dpl/static_block.h>
+#include <installer_log.h>
////////////////////////////////////////////////////////////////////////////////
WrtDB::PluginDAOReadOnly pdao(#LIBNAME); \
RUNNER_ASSERT_MSG(pdao.getInstallationStatus() == WrtDB::PluginDAOReadOnly::INSTALLATION_COMPLETED, "Plugin is not installed correctly"); \
} Catch(DPL::Exception) { \
- LogError(_rethrown_exception.DumpToString()); \
+ _E("%s", _rethrown_exception.DumpToString().c_str()); \
RUNNER_ASSERT_MSG(false, "DPL::Exception"); \
} \
} \
*/
#include <dpl/test/test_runner.h>
-#include <dpl/log/log.h>
+#include <installer_log.h>
#include <dpl/wrt-dao-ro/WrtDatabase.h>
int main (int argc, char *argv[])
{
- LogDebug("Starting tests");
+ _D("Starting tests");
WrtDB::WrtDatabase::attachToThreadRW();
int status =
projects / platform / framework / web / wrt-installer.git / commitdiff