Ejemplo n.º 1
0
void KoodevStopwatch::dump()
{
    long prevTime = 0;
    for (unsigned int i = 0; i < m_labTimeRecords.size(); i++) {
        const long currentTime = getTime(m_labTimeRecords[i].labTimeval);
        const long labTime = currentTime - prevTime;
        prevTime = currentTime;
        if (labTime > 0 || !m_ignoreZeroDump)
            dumpMessage(labTime, m_labTimeRecords[i].tag.data());
    }
    if (!m_started) {
        const long labTime = getTime();
        if (labTime > 0 || !m_ignoreZeroDump)
            dumpMessage(labTime);
    }
}
void QDBusViewer::setProperty(const BusSignature &sig)
{
    QDBusInterface iface(sig.mService, sig.mPath, sig.mInterface, c);
    QMetaProperty prop = iface.metaObject()->property(iface.metaObject()->indexOfProperty(sig.mName.toLatin1()));

    bool ok;
    QString input = QInputDialog::getText(this, tr("Arguments"),
                    tr("Please enter the value of the property %1 (type %2)").arg(
                        sig.mName, QString::fromLatin1(prop.typeName())),
                    QLineEdit::Normal, QString(), &ok);
    if (!ok)
        return;

    QVariant value = input;
    if (!value.convert(prop.type())) {
        QMessageBox::warning(this, tr("Unable to marshall"),
                tr("Value conversion failed, unable to set property"));
        return;
    }

    QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, QLatin1String("org.freedesktop.DBus.Properties"), QLatin1String("Set"));
    QList<QVariant> arguments;
    arguments << sig.mInterface << sig.mName << qVariantFromValue(QDBusVariant(value));
    message.setArguments(arguments);
    c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage)));

}
void QDBusViewer::connectionRequested(const BusSignature &sig)
{
    if (!c.connect(sig.mService, QString(), sig.mInterface, sig.mName, this,
              SLOT(dumpMessage(QDBusMessage)))) {
        logError(tr("Unable to connect to service %1, path %2, interface %3, signal %4").arg(
                    sig.mService).arg(sig.mPath).arg(sig.mInterface).arg(sig.mName));
    }
}
void QDBusViewer::getProperty(const BusSignature &sig)
{
    QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, QLatin1String("org.freedesktop.DBus.Properties"), QLatin1String("Get"));
    QList<QVariant> arguments;
    arguments << sig.mInterface << sig.mName;
    message.setArguments(arguments);
    c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage)));
}
void QDBusViewer::callMethod(const BusSignature &sig)
{
    QDBusInterface iface(sig.mService, sig.mPath, sig.mInterface, c);
    const QMetaObject *mo = iface.metaObject();

    // find the method
    QMetaMethod method;
    for (int i = 0; i < mo->methodCount(); ++i) {
        const QString signature = QString::fromLatin1(mo->method(i).signature());
        if (signature.startsWith(sig.mName) && signature.at(sig.mName.length()) == QLatin1Char('('))
            if (getDbusSignature(mo->method(i)) == sig.mTypeSig)
                method = mo->method(i);
    }
    if (!method.signature()) {
        QMessageBox::warning(this, tr("Unable to find method"),
                tr("Unable to find method %1 on path %2 in interface %3").arg(
                    sig.mName).arg(sig.mPath).arg(sig.mInterface));
        return;
    }

    PropertyDialog dialog;
    QList<QVariant> args;

    const QList<QByteArray> paramTypes = method.parameterTypes();
    const QList<QByteArray> paramNames = method.parameterNames();
    QList<int> types; // remember the low-level D-Bus type
    for (int i = 0; i < paramTypes.count(); ++i) {
        const QByteArray paramType = paramTypes.at(i);
        if (paramType.endsWith('&'))
            continue; // ignore OUT parameters

        QVariant::Type type = QVariant::nameToType(paramType);
        dialog.addProperty(QString::fromLatin1(paramNames.value(i)), type);
        types.append(QMetaType::type(paramType));
    }

    if (!types.isEmpty()) {
        dialog.setInfo(tr("Please enter parameters for the method \"%1\"").arg(sig.mName));

        if (dialog.exec() != QDialog::Accepted)
            return;

        args = dialog.values();
    }

    // Special case - convert a value to a QDBusVariant if the
    // interface wants a variant
    for (int i = 0; i < args.count(); ++i) {
        if (types.at(i) == qMetaTypeId<QDBusVariant>())
            args[i] = qVariantFromValue(QDBusVariant(args.at(i)));
    }

    QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, sig.mInterface,
            sig.mName);
    message.setArguments(args);
    c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage)));
}
Ejemplo n.º 6
0
int handleMessage(struct __message msg)
{
	struct timeval timeFinished;
	
	gettimeofday(&timeFinished, NULL);
	msg.client_finished.tv_sec = timeFinished.tv_sec;
	msg.client_finished.tv_usec = timeFinished.tv_usec;
	
	dumpMessage(msg);
	
	return 0;
}
Ejemplo n.º 7
0
static void dumpBodypart( Message * m, Bodypart * bp, int n )
{
    dumpMultipart( bp, n );

    if ( bp->message() ) {
        dumpMessage( bp->message(), n+4 );
    }
    else {
        List< Bodypart >::Iterator it( bp->children() );
        while ( it ) {
            dumpBodypart( m, it, n+2 );
            ++it;
        }
    }
}
/******************************************************************************
 * Function 'runForever' 
 * This function will do most of the programs work. It will take in all the packets
 * (which realistically, should make this a continuously running function) and call
 * the function for them to be read. It will take these read packets and add them to
 * messages and then add these messages to the  MessagesMap. It will test if a message
 * has been completed upon the addition of a packet and call the messageDump function 
 * to remove and output a message if it is done. In the scale of this program, this function
 * runs until all the messages are complete and there are no more packets to take in.
 *
 * Parameters:
 * scanner - the 'Scanner' from which to read 
 * outStream - the stream to which to write
 *
 * Returns: None
 *
 * Output: Adds each completed message to the OutStream. 
**/
void PacketAssembler::runForever(Scanner& scanner, ofstream& outStream)
{
#ifdef EBUG
  Utils::logStream << "enter runForever\n"; 
#endif

  Packet tempPacket; 
  int tempMessageID; 
  
  //run as long as there are more packets to take in. 
  while(scanner.hasNext()) 
  {
    //create a temporary packet and call the read from the Packet class to assign it values
    tempPacket = Packet(scanner);
    tempMessageID = tempPacket.getMessageID(); 
    //using this packets MessageID, check if we already have this message
    if (messagesMapContains(tempMessageID) == false)
    {
      //if not create a new Message and push it into the messagesMap
      Message tempMessage;
      tempMessage.insert(tempPacket); 
      messagesMap.insert(std::pair<int, Message>(tempMessageID, tempMessage));   
    } 
   
    //otherwise, this message is in the Messages map and we should just add the new
    //packet to the message already in the messages map. 
    else 
    {
      if(messagesMapContains(tempMessageID))
      {
        messagesMap[tempMessageID].insert(tempPacket); 
      }
    }  
  
    //after adding each packet, we should check if that packet completed a message
    if (messagesMap[tempMessageID].isComplete() == true)
    {
      //if it did, dump it and outStream the data. 
      outStream << "The Completed message is: ";
      outStream << "\n";  
      outStream << dumpMessage(tempMessageID); 
    }
  } 

#ifdef EBUG
  Utils::logStream << "leave runForever\n"; 
#endif
}
Ejemplo n.º 9
0
int handleMessage(struct __message *arg)
{
	struct timeval timeStart, timeEnd;
	struct __message msg;

	//TODO: rx delay
	usleep(DELAY_SERVER_RX*1000);

	memcpy(&msg, arg, sizeof(struct __message));

	gettimeofday(&timeStart, NULL);
	
#if ENABLE_MUTEX	
	pthread_mutex_lock(&m_lock);
#endif
    		
	//TODO: process delay
	usleep(DELAY_SERVER_PROCESS*1000);
	
#if ENABLE_MUTEX
	pthread_mutex_unlock(&m_lock);
#endif	//#if ENABLE_MUTEX

	gettimeofday(&timeEnd, NULL);

	setTimeValue(&(msg.server_started), timeStart.tv_sec, timeStart.tv_usec);
	setTimeValue(&(msg.server_finished), timeEnd.tv_sec, timeEnd.tv_usec);

#if 0
	msg.resource =  timeEnd.tv_sec%1000000;
	msg.uiMaxAge = (1000000-timeEnd.tv_usec)/1000;
#else
	msg.resource =  g_iCount++;
	msg.uiMaxAge = (DELAY_SERVER_PROCESS);
#endif	
	//TODO: tx delay
	usleep(DELAY_SERVER_TX*1000);

	//printf("[%d-%d]Resource=%d, uiMaxAge=%d, msg.iFd=%d ", msg.owner, msg.cnt, msg.resource, msg.uiMaxAge, msg.iFd);
	
	int temp = send(msg.iFd, &msg, sizeof(struct __message), 0);
	
#if 1
	dumpMessage(msg);
#endif	
	
	return 0;
}
Ejemplo n.º 10
0
void *pthreadWatchResource(void *arg)
{
	struct timeval timeSched;
	struct timeval tStart;
			
	while(!g_iExit)
	{
		if(g_Resource1.iClientNumber)
		{
			//TODO: get current time
			//gettimeofday(&tStart, NULL);

			//TODO: search all clients registered
			struct __client *client = g_Resource1.next;
			while(client)
			{
				gettimeofday(&tStart, NULL);

				//TODO: find scheduled client
				if(isBiggerThan(tStart, client->tSched))
				{
					struct __message msg;
					struct timeval tEnd;

					//TODO: if cached resource is valid, then use it
					if(g_uiCacheMode && isCachedDataValid(tStart) )
					{
						//TODO: update cache timing information
						updateCache(tStart);
						
						//TODO: set server process time with zero
						setTimeValue(&(msg.server_recved), 0, 0);
						setTimeValue(&(msg.server_started), 0, 0);
						setTimeValue(&(msg.server_finished), 0, 0);
						
						//TODO: set message with time information		
						msg.resource = g_Resource1.iCachedResource;
						msg.uiMaxAge = g_Resource1.uiMaxAge - g_Resource1.uiCachedAge;
						//printf("%s:uiMaxAge=%d(%d-%d)\n", __func__, msg.uiMaxAge, g_Resource1.uiMaxAge, g_Resource1.uiCachedAge);	
						
						//TODO: get current time
						gettimeofday(&tEnd, NULL);
					}
					else
					{
						//TODO: init cache
						initCache();
						
						//TODO: get a fresh resource from a server
						getResourceFromServer(&msg);
						
						//TODO: get current time
						gettimeofday(&tEnd, NULL);
					
						//TODO: set cached with information
						setCache(msg, tEnd);
					}
					
					//TODO: set client process time
					setTimeValue(&(msg.client_recved), 0, 0);
					setTimeValue(&(msg.client_started), 0, 0);
					
					//TODO: set proxy process time
					setTimeValue(&(msg.proxy_recved), tStart.tv_sec, tStart.tv_usec);
					setTimeValue(&(msg.proxy_started), tStart.tv_sec, tStart.tv_usec);
					setTimeValue(&(msg.proxy_finished), tEnd.tv_sec, tEnd.tv_usec);

					//TODO: dump message
					dumpMessage(msg);
					
					//TODO: send information as response from proxy to client
					int temp = send(client->iFd, &msg, sizeof(struct __message), 0);
					
					//TODO: set a new scheduled time of client
					struct timeval tB;
					tB.tv_sec = client->uiReqInterval/1000;
					tB.tv_usec = (client->uiReqInterval%1000)*1000;
					addTimeValue(&(client->tSched), client->tSched, tB);
					
//printf("tStart=%ld.%06ld, tSched=%ld.%06ld\n", 
//	tStart.tv_sec, tStart.tv_usec,
//	client->tSched.tv_sec, client->tSched.tv_usec);
				}
				client = client->next;
//printf("%s:client=0x%x\n", __func__, (unsigned int)client);
			}
			
			//TODO: inser client node as time sequence
			//updateClient();
			
			//TODO: 
			if(g_uiCacheAlgorithm == 1)
			{
				if(isBiggerThan(tStart, g_Resource1.tBaseTime))
				{
					//TODO: update check point
					updateBaseTime();
				}
			}
			else if(g_uiCacheAlgorithm == 2)
			{
				struct timeval tCPaddMA; 
				struct timeval tMaxAge; 
				setTimeValue(&tMaxAge, g_Resource1.uiMaxAge/1000, (g_Resource1.uiMaxAge%1000)*1000);
				addTimeValue(&tCPaddMA, g_Resource1.tBaseTime, tMaxAge);				
				if(isBiggerThan(tStart, tCPaddMA))
				{
					setSchedule(tStart);
				}
			}			
			
			usleep(5*1000);
		}	//if(g_Resource1.iClientNumber)
		
		usleep(50*1000);
	}
		
	return NULL;
}
Ejemplo n.º 11
0
int handleMessage(struct __message *arg)
{
	struct timeval tStart;
	struct __message msg = {0x0, };
	struct __message resp = {0x0, };

	memcpy(&msg, arg, sizeof(struct __message));

	//TODO: handle packet
	//gettimeofday(&tStart, NULL);

	//TODO: wait until other request responded
	pthread_mutex_lock(&m_lock);
	
	gettimeofday(&tStart, NULL);

	//TODO: use cached resource
	if(msg.cmd == RESOURCE_CMD_REGISTER)
	{
		if(g_uiCacheAlgorithm == 0)
		{
			addObserver0(msg.owner, msg.iFd, msg.resource, msg.req_dur);
		}
		else if(g_uiCacheAlgorithm == 1)
		{
			addObserver1(msg.owner, msg.iFd, msg.resource, msg.req_dur, tStart);
		}
		else if(g_uiCacheAlgorithm == 2)
		{
			addObserver1(msg.owner, msg.iFd, msg.resource, msg.req_dur, tStart);
		}
		dumpObserver();
	}
	else if (msg.cmd == RESOURCE_CMD_GET)
	{
		struct timeval tEnd;
		
		//TODO: get cached resource
		if(g_uiCacheMode && isCachedDataValid(tStart))
		{
			//TODO: update cache timing information
			updateCache(tStart);
			
			//TODO: set server process time with zero
			setTimeValue(&(msg.server_recved), 0, 0);
			setTimeValue(&(msg.server_started), 0, 0);
			setTimeValue(&(msg.server_finished), 0, 0);
			
			//TODO: set message with time information		
			gettimeofday(&tEnd, NULL);
			
			//TODO: set message with time information		
			msg.resource = g_Resource1.iCachedResource;
			msg.uiMaxAge = g_Resource1.uiMaxAge - g_Resource1.uiCachedAge;

			printf("CACHED! Owner=%d, R=%d, MaxAge=%d, CachedAge=%d(%ld.%06ld)\n", 
				msg.owner,
				g_Resource1.iCachedResource, 
				g_Resource1.uiMaxAge,
				g_Resource1.uiCachedAge,
				tEnd.tv_sec%1000,	\
				tEnd.tv_usec
				);
		}
		else
		{
			//TODO: init cache
			initCache();
	
			//TODO: get a fresh resource from a server
			getResourceFromServer(&msg);

			//TODO: get current time
			gettimeofday(&tEnd, NULL);
	
			//TODO: set cached with information
			setCache(msg, tEnd);
		
			printf("NOT cached! Owner=%d, R=%d, MaxAge=%d, CachedAge=%d(%ld.%06ld)\n",
				msg.owner,
				g_Resource1.iCachedResource, 
				g_Resource1.uiMaxAge,
				g_Resource1.uiCachedAge,
				tEnd.tv_sec%1000,	\
				tEnd.tv_usec
				);
		}
		
		//TODO: set client process time
		//setTimeValue(&(msg.client_recved), 0, 0);
		//setTimeValue(&(msg.client_started), 0, 0);
					
		//TODO: set proxy process time
		//setTimeValue(&(msg.proxy_recved), tStart.tv_sec, tStart.tv_usec);
		setTimeValue(&(msg.proxy_started), tStart.tv_sec, tStart.tv_usec);
		setTimeValue(&(msg.proxy_finished), tEnd.tv_sec, tEnd.tv_usec);

		//TODO: send information as response from proxy to client
		int temp = send(msg.iFd, &msg, sizeof(struct __message), 0);

		//TODO: set a new scheduled time of client
		/*
		struct timeval tB;
		tB.tv_sec = client->uiReqInterval/1000;
		tB.tv_usec = (client->uiReqInterval%1000)*1000;
			addTimeValue(&(client->tSched), client->tSched, tB);
		*/
#if 1
	dumpMessage(msg);
#endif
	}
	
	pthread_mutex_unlock(&m_lock);
//printf("---\n");		
	return 0;
}
/*
 * On linux this is not how we create processes. We send a message
 * to a server to clone itself, and then we message it. That is layered
 * on top of the messaging system
 */
static int 
create_process(char **cmd_args, int argc, char** argv)
{
    JUMPPlatformCString type = "mvm/server";
    JUMPOutgoingMessage outMessage;
    JUMPMessage response;
    JUMPMessageMark mark;
    JUMPAddress targetAddress;
    JUMPMessageStatusCode code;
    int numWords = 0;
    int i;
    char * vmArgs, *s;
    
    if (cmd_args == NULL || *cmd_args == NULL) {
	/* Nothing to do */
	return -1;
    }
    outMessage = jumpMessageNewOutgoingByType(type, &code);
    jumpMessageMarkSet(&mark, outMessage);
    /*
     * We don't yet know how many strings we will be adding in, so
     * put in a placeholder for now. We marked the spot with &mark.
     */
    jumpMessageAddInt(outMessage, numWords);
    
    /* Start with the command. It should be JAPP or JNATIVE */
    jumpMessageAddString(outMessage, *cmd_args);
    numWords ++;
    cmd_args ++;
    
    /*
     * The argv[0] is the VM arugment, which needs to be placed
     * right after 'JAPP'.
     */
    vmArgs = argv[0];
    if (strcmp(vmArgs, "")) {
        s = strchr(vmArgs, ' ');
        while (s != NULL) {
            *s = '\0';
            jumpMessageAddString(outMessage, vmArgs);
            numWords ++;
            vmArgs = s + 1;
            s = strchr(vmArgs, ' ');
        }
        if (*vmArgs != '\0') {
            jumpMessageAddString(outMessage, vmArgs);
            numWords ++;
	}
    }

    /* Rest of the cmd argument list: e.g. ..JUMPIsolateProcessImpl */
    while (*cmd_args != NULL) {
	jumpMessageAddString(outMessage, *cmd_args);
	numWords ++;
	cmd_args ++;
    }
    
    /* 
     * If we do argc, argv[] for main(), this is how we would put those in
     */
    for (i = 1; i < argc; i++) {
	jumpMessageAddString(outMessage, (char*)argv[i]);
    }
    numWords = numWords + argc - 1;

    /* Now that we know what we are sending, patch message with count */
    jumpMessageMarkResetTo(&mark, outMessage);
    jumpMessageAddInt(outMessage, numWords);
    
    /* And now, for dumping purposes */
    jumpMessageMarkResetTo(&mark, outMessage);
    dumpMessage(outMessage, "Outgoing message:");

    /* Time to send outgoing message */
    targetAddress.processId = serverPid;
    /* FIXME: Must have central location for timeout values */
#define TIMEOUT 10000
    response = jumpMessageSendSync(targetAddress, outMessage, TIMEOUT, &code);
    if (response == NULL) {
        return -1;
    }
    dumpMessage(response, "Command response:");
    return getChildPid(response);
}