void ProfilerCommunication::RequestInformation(BR buildRequest, PR processResults, DWORD dwTimeout, tstring message)
{
    try {
        buildRequest();
    
        DWORD dwSignal = m_eventProfilerRequestsInformation.SignalAndWait(m_eventInformationReadyForProfiler, dwTimeout);
        if (WAIT_OBJECT_0 != dwSignal) throw CommunicationException(dwSignal);
    
        m_eventInformationReadyForProfiler.Reset();

        BOOL hasMore = FALSE;
        do
        {
            hasMore = processResults();

            if (hasMore)
            {
                dwSignal = m_eventInformationReadByProfiler.SignalAndWait(m_eventInformationReadyForProfiler, COMM_WAIT_SHORT);
                if (WAIT_OBJECT_0 != dwSignal) throw CommunicationException(dwSignal);
            
                m_eventInformationReadyForProfiler.Reset();
            }
        }while (hasMore);

        m_eventInformationReadByProfiler.Set();
    } catch (CommunicationException ex) {
        RELTRACE(_T("ProfilerCommunication::RequestInformation(...) => Communication (Chat channel - %s) with host has failed (0x%x)"),  
            message.c_str(), ex.getReason());
        hostCommunicationActive = false;
    }
}
Exemple #2
0
bool DEProtoProxy::receiveFromServer(DEPacket& pkt)
{
	long pktSize = 0;

	// Get Packet size.
	if (!this->server->receive((void*)&pktSize, sizeof(unsigned long), this->paramTimeout))
	{
		BOOST_THROW_EXCEPTION(CommunicationException() << errorMessage("Unable to receive message size from server.\n"));
	}
	else { 
		this->recvBufferNew.resizeIfNeeded(pktSize);
	}

	if (!this->server->receive((void*)this->recvBufferNew.getBufferPtr(), pktSize, this->paramTimeout * 2))
	{
		BOOST_THROW_EXCEPTION(CommunicationException() << errorMessage("Unable to receive message from server.\n"));
	}

	if (!pkt.ParseFromArray(this->recvBufferNew.getBufferPtr(), pktSize))
	{
		BOOST_THROW_EXCEPTION(CommunicationException() << errorMessage("Unable to parse message on receipt from server.\n"));
	}

	return true;
}
Exemple #3
0
bool DEProtoProxy::get_Image(void* image, unsigned int length)
{
	boost::lock_guard<boost::mutex>(*this->server->getTransactionMutex());

	DEPacket pkt, dataHeader;
	pkt.set_type(DEPacket::P_COMMAND);
	SingleCommand* cmd = pkt.add_command();
	cmd->set_command_id(k_GetImage);

	this->sendCommand(pkt);
	this->receiveFromServer(dataHeader);
	if (dataHeader.type() != DEPacket::P_DATA_HEADER ||
		!dataHeader.has_data_header()) 
		BOOST_THROW_EXCEPTION(ProtocolException() << errorMessage("Did not receive expected data header for image."));
	
	this->imgBuffer.resizeIfNeeded(static_cast<std::size_t>(dataHeader.data_header().bytesize()));

	if (!this->server->receive(this->imgBuffer.getBufferPtr(), static_cast<std::size_t>(dataHeader.data_header().bytesize()), this->imageTimeout))
	{
		BOOST_THROW_EXCEPTION(CommunicationException() << errorMessage("Unable to receive image from server."));
	}

	if (dataHeader.data_header().bytesize() != length)
	{
		BOOST_THROW_EXCEPTION(CommandException() << errorMessage ("Image received did not have the expected size"));
	}

	memcpy(image, this->imgBuffer.getBufferPtr(), length);

	return true;
}
/********************************************************************************
 * Functions
 */
INetworkAccessProvider* CommunicationService::provider() {
    instance();
    if (_instance->_provider == 0) {
        throw CommunicationException("No provider defined.");
    }
    return _instance->_provider;
}
Exemple #5
0
void VsftpdConfigHandler::restart() const
{
    int exitStatus = ServiceManager::restart(m_serviceName);
    if (exitStatus == 1) {
        std::string err("The process crashed.");
        throw CommunicationException(err.c_str());
    }
 }
Exemple #6
0
void Provider::bindObjectToName(const char* name, CORBA::Object_ptr objectRef) {
    try {
        CosNaming::Name objectName;
        objectName.length(2);
        objectName[0].id = CONTEXT_NAME_ID;
        objectName[0].kind = CONTEXT_NAME_KIND;
        objectName[1].id = name;
        objectName[1].kind = CONTEXT_OBJECT_KIND;
        try {
            this->_naming->bind(objectName, objectRef);
        } catch(CosNaming::NamingContext::AlreadyBound& ex) {
            this->_naming->rebind(objectName, objectRef);
        }
    } catch(CORBA::TRANSIENT &) {
        throw CommunicationException("The naming service could not be found, make sure it is correctly started.");
    } catch(CORBA::SystemException & e) {
        throw CommunicationException(QString("Receive a corba system error: ") + e._name());
    }
}
Exemple #7
0
IServerConfigurationProvider* Provider::getServiceClient(const QString& name) {
    if (CORBA::is_nil(this->_naming)) {
        throw CommunicationException("Naming service is not properly started, cannot locate provider");
    }
    try {
        CosNaming::Name cname;
        cname.length(2);
        cname[0].id   = CONTEXT_NAME_ID;
        cname[0].kind = CONTEXT_NAME_KIND;
        cname[1].id   = name.toStdString().c_str();
        cname[1].kind = CONTEXT_OBJECT_KIND;
        return new ServiceClientAdapter(ServerConfigHandler::_narrow(this->_naming->resolve(cname)));
    } catch (const CORBA::COMM_FAILURE& e) {
        throw CommunicationException("Cannot communicate with the naming service, make sure it is still alive.");
    } catch (...) {
        throw CommunicationException("An unknown error occurred, unable to retrieve the requested service.");
    }
    return 0;
}
Exemple #8
0
void Provider::registerServiceProvider(const QString& name, IServerConfigurationProvider* provider) {
    if (CORBA::is_nil(this->_naming)) {
        throw CommunicationException("Naming service is not properly started, cannot register provider");
    }
    try {
        ServiceAdapter* handler = new ServiceAdapter(provider);
        _handlers[provider->getServerName()] = handler;
        this->_poa->activate_object(handler);
        this->bindObjectToName(name.toStdString().c_str(), handler->_this());
        handler->_remove_ref();
        this->_poa->the_POAManager()->activate();
    } catch(const CORBA::SystemException& e) {
        throw CommunicationException(QString("Receive a corba system error: ") + e._name());
    } catch(const CORBA::Exception& e) {
        throw CommunicationException(QString("Receive a corba error: ") + e._name());
    } catch(const omniORB::fatalException& e) {
        throw CommunicationException(QString("Receive an omniORB fatal error: ") + e.errmsg());
    }
}
void ProfilerCommunication::SendVisitPoints()
{
    if (!hostCommunicationActive) return;
    try {
        DWORD dwSignal = m_eventProfilerHasResults.SignalAndWait(m_eventResultsHaveBeenReceived, COMM_WAIT_SHORT);
        if (WAIT_OBJECT_0 != dwSignal) throw CommunicationException(dwSignal);
        m_eventResultsHaveBeenReceived.Reset();
    } catch (CommunicationException ex) {
        RELTRACE(_T("ProfilerCommunication::SendVisitPoints() => Communication (Results channel) with host has failed (0x%x)"), ex.getReason());
        hostCommunicationActive = false;
    }
    return;
}
void CommunicationService::configure(INetworkAccessProvider::MODE::mode mode, const QMap<QString, QString>& options) {
    instance();
    if (_instance->_provider == 0) {
        throw CommunicationException("No provider defined.");
    }
    // Register custom type into QMetaType system
    qRegisterMetaTypeStreamOperators<int>("IServerConfigurationProvider_INTERNET_PROTOCOL");
    qRegisterMetaTypeStreamOperators<int>("IServerConfigurationProvider_VIRTUAL_USER_AUTHENTICATION");
    // Configure provider
    try {
        _instance->_provider->configure(mode, options);
    } catch (const CommunicationException& e) {
        qCritical() << "Error while configuring the network provider: " << e.message();
    }
}
Exemple #11
0
void VsftpdConfigHandler::importConfiguration(const QString & configuration)
{
    QFile file(m_parser.filename());

    if (!file.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
        std::string err("Unable to access configuration file.");
        std::cerr << err << std::endl;
        throw CommunicationException(err.c_str());
    }

    QTextStream out(&file);
    out << configuration;

    file.close();
}
Exemple #12
0
QString VsftpdConfigHandler::exportConfiguration() const
{
    QFile file(m_parser.filename());

    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        std::string err("Unable to access configuration file.");
        std::cerr << err << std::endl;
        throw CommunicationException(err.c_str());
    }

    QTextStream in(&file);
    QString data = in.readAll();

    file.close();

    return data;
}
Exemple #13
0
bool DEProtoProxy::sendToServer(DEPacket& pkt)
{
	int sz = sizeof(unsigned long);
	pkt.set_camera_name(this->_cameraName);

	int pktSize = pkt.ByteSize();

	this->sendBufferNew.resetOffset();
	this->sendBufferNew.add(pktSize);
	this->sendBufferNew.add(pkt);

	if (!this->server->send(this->sendBufferNew.getBufferPtr(), pktSize + sz, 5))
	{
		BOOST_THROW_EXCEPTION(CommunicationException() << errorMessage("Unable to send message to server")
			<< boost::errinfo_file_name(__FILE__)
			<< boost::errinfo_at_line(__LINE__)
			<<errorPacket(pkt));
	}

	return true;
}
Exemple #14
0
void Provider::configure(MODE::mode mode, const QMap<QString, QString>& options) {
    qDebug() << "Configuring CORBA Provider...";
    // Provider...
    try {
        char* args[] = { 0 };
        int argc     = 0;

//        const char* opts[options.size() + 1][2];
//        opts[options.size()][0] = 0;
//        opts[options.size()][1] = 0;
//        int i = 0;
//        for (QMap<QString, QString>::const_iterator it = options.begin(); it != options.end(); i++, it++) {
//            opts[i][0] = strdup(it.key().toStdString().c_str());
//            opts[i][1] = strdup(it.value().toStdString().c_str());
//        }
        const char* opts[2][2];
        if (options.contains("InitRef")) {
            opts[0][0] = strdup("InitRef");
            opts[0][1] = strdup(options["InitRef"].toStdString().c_str());
        }
        else {
            opts[0][0] = 0;
            opts[0][1] = 0;
        }
        opts[1][0] = 0;
        opts[1][1] = 0;

        this->_orb = CORBA::ORB_init(argc, args, "omniORB4", opts);
        if (mode == INetworkAccessProvider::MODE::SERVER) {
            this->_poa = PortableServer::POA::_narrow(this->_orb->resolve_initial_references("RootPOA"));
            if (CORBA::is_nil(this->_poa)) {
                throw CommunicationException("Failed to narrow the root POA.");
            }
        }

        this->_naming = CosNaming::NamingContext::_narrow(this->_orb->resolve_initial_references("NameService"));
        if (CORBA::is_nil(this->_naming)) {
            throw CommunicationException("Failed to narrow the root naming context.");
        }

        if (mode == INetworkAccessProvider::MODE::SERVER) {
            CosNaming::Name contextName;
            contextName.length(1);
            contextName[0].id = CONTEXT_NAME_ID;
            contextName[0].kind = CONTEXT_NAME_KIND;
            try {
                this->_naming->bind_new_context(contextName);
            } catch(CosNaming::NamingContext::AlreadyBound& ex) {
                //std::cerr << "Server context already exists, trying to narrow existing context." << std::endl;
                if (CORBA::is_nil(CosNaming::NamingContext::_narrow(this->_naming->resolve(contextName)))) {
                    throw CommunicationException("Failed to narrow naming context.");
                }
            }
        }
    // For details on CORBA Exception:
    //   http://techpubs.borland.com/am/bes/v6/en/updates/except_cpp.html
    } catch (const CORBA::NO_RESOURCES& e) {
        throw CommunicationException("No resources found, please verify the configuration of omniORB.");
    } catch (const CORBA::ORB::InvalidName& e) {
        throw CommunicationException("Service required is invalid or does not exist.");
    } catch(const CORBA::TRANSIENT& e) {
        throw CommunicationException("The naming service could not be found, make sure it is correctly started.");
    } catch(CORBA::SystemException & e) {
        throw CommunicationException(QString("Receive a CORBA system error: ") + e._name());
    } catch(const CORBA::Exception& e) {
        std::string err();
        throw CommunicationException(QString("Receive a CORBA error: ") + e._name());
    } catch(const omniORB::fatalException& e) {
        std::string err();
        throw CommunicationException(QString("Receive an omniORB fatal error: ") + e.errmsg());
    } catch (const CommunicationException& e) {
        throw e;
    } catch (...) {
        throw CommunicationException("An unknown error occurred while configuring the network layer.");
    }
    qDebug() << "Configuration of CORBA Provider done, ready.";
}