OpcServer.cxx

Go to the documentation of this file.

/******************************************************************************
** opcserver.cpp
**
** Copyright (C) 2008-2009 Unified Automation GmbH. All Rights Reserved.
** Web: http://www.unified-automation.com
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** Project: C++ OPC Server SDK sample code
**
** Description: Main OPC Server object class.
**
******************************************************************************/
#include "OpcServer.h"
#include "uamutex.h"
#include "srvtrace.h"
#include "UaCanTrace.h"
#include "serverconfigxml.h"

ServerConfigXml*      OpcServer::m_pServerConfig =  0;


class ServerConfigBasicXml: public ServerConfigXml
{
public:
    ServerConfigBasicXml(const UaString& sXmlFileName, const UaString& sApplicationPath, OpcServerCallback* pOpcServerCallback);
    ~ServerConfigBasicXml(){}
    UaStatus afterLoadConfiguration(){return OpcUa_Good;}
    UaStatus startUp(ServerManager*){return OpcUa_Good;}
    UaStatus shutDown(){return OpcUa_Good;}
    Session* createSession(OpcUa_Int32 sessionID, const UaNodeId &authenticationToken);
    UaStatus logonSessionUser(Session* pSession, UaUserIdentityToken* pUserIdentityToken);
private:
    OpcServerCallback* m_pOpcServerCallback;
};

OpcServer::~OpcServer()
{

    if ( m_isStarted != OpcUa_False )
    {
        UaLocalizedText reason("en","Application shut down");
        stop(0, reason);
    }

    if ( m_pUaModule )
    {
        delete m_pUaModule;
        m_pUaModule = NULL;
    }

    if ( m_pCoreModule )
    {
        delete m_pCoreModule;
        m_pCoreModule = NULL;
    }

    // Delete all node managers
    list<NodeManager*>::iterator it;
    for ( it = m_listNodeManagers.begin(); it != m_listNodeManagers.end(); it++ )
    {
        delete (*it);
        (*it) = NULL;
    }
    m_listNodeManagers.clear();

    if ( m_pServerConfig )
    {
        delete m_pServerConfig;
        m_pServerConfig = NULL;
    }
}

int OpcServer::setServerConfig(const UaString& configurationFile, const UaString& applicationPath)
{
    UaMutexLocker lock(&m_mutex);
    if ( m_isStarted != OpcUa_False )
    {
        // Error, the method is called after the server was started
        return -1;
    }

    m_configurationFile = configurationFile;
    m_applicationPath = applicationPath;
//      m_CanTraceFile = canTraceFile;

        if ( m_pServerConfig == NULL )
    {
        UaUniString sConfigFile(m_configurationFile.toUtf8());
        sConfigFile = sConfigFile.toLower();
       if ( sConfigFile.lastIndexOf(".xml") > (sConfigFile.length() - 5) )
        {
            m_pServerConfig = new ServerConfigBasicXml(m_configurationFile, m_applicationPath/*, m_CanTraceFile*/, m_pOpcServerCallback);
        }
    }
    // Check trace settings
        if ( m_pServerConfig->loadConfiguration().isGood() )
    {
                // Check trace settings
                if (m_pServerConfig)
                {
                        OpcUa_Boolean bTraceEnabled = OpcUa_False;
                        OpcUa_UInt32  uTraceLevel = 0;
                        OpcUa_Boolean bSdkTraceEnabled = OpcUa_False;
                        OpcUa_UInt32  uSdkTraceLevel = 0;
                        OpcUa_UInt32  uMaxTraceEntries = 0;
                        OpcUa_UInt32  uMaxBackupFiles = 0;
                        UaString      sTraceFile;
                        OpcUa_Boolean bDisableFlush;

                        m_pServerConfig->getStackTraceSettings(bTraceEnabled, uTraceLevel);

                        m_pServerConfig->getServerTraceSettings(
                                bSdkTraceEnabled,
                                uSdkTraceLevel,
                                uMaxTraceEntries,
                                uMaxBackupFiles,
                                sTraceFile, bDisableFlush);

                        if (bSdkTraceEnabled != OpcUa_False)
                        {
                                SrvT::initTrace((UaTrace::TraceLevel)uSdkTraceLevel, uMaxTraceEntries, uMaxBackupFiles, sTraceFile, "OpcUaCanOpenServer");
                                SrvT::setLocalTimeOutput(true);
                                SrvT::setTraceActive(true);
                                if (bTraceEnabled != OpcUa_False)
                                {
                                        SrvT::setStackTraceActive(OpcUa_True, uTraceLevel);
                                }
                        }
                }

                CanOpen::UaCanTrace::initTraceComponent();

                LOG(Log::INF, CanOpen::UaCanTrace::NoTrace) << "Load Configuration";
                cout << "Load Configuration" << endl;

                return OpcUa_Good;
        }

        return 0;
}

int OpcServer::setServerConfig(ServerConfig* pServerConfig)
{
    UaMutexLocker lock(&m_mutex);
    if ( m_isStarted != OpcUa_False )
    {
        // Error, the method is called after the server was started
        return -1;
    }

    m_pServerConfig = (ServerConfigXml*)pServerConfig;
        return 0;
}

int OpcServer::addNodeManager(NodeManager* pNodeManager)
{
    UaMutexLocker lock(&m_mutex);

    m_listNodeManagers.push_back(pNodeManager);

    if ( m_isStarted != OpcUa_False )
    {
        // Start up node manager if server is already started
        UaStatus ret = pNodeManager->startUp(m_pServerManager);
        if ( ret.isNotGood() )
        {
            TRACE1_ERROR(SERVER_UI, "Error: OpcServer::addNodeManager - can not start up node manager [ret=0x%lx]", ret.statusCode());
            return -1;
        }
    }

    return 0;
}