891 lines
26 KiB
C++
891 lines
26 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
//
|
|
// TestHarness.cpp : Defines the entry point for the console application.
|
|
// Currently tests the basic API of the SwarmInterface library
|
|
//
|
|
|
|
#include <conio.h>
|
|
#include <stdio.h>
|
|
#include <tchar.h>
|
|
#include <time.h>
|
|
|
|
#include <Windows.h>
|
|
#include "../../../Editor/Windows/UnrealSwarm/Public/SwarmDefines.h"
|
|
#include "../../../Editor/Windows/UnrealSwarm/Public/SwarmInterface.h"
|
|
using namespace NSwarm;
|
|
|
|
|
|
// The primary system callback
|
|
int OutstandingPings = 0;
|
|
int OutstandingTasks = 0;
|
|
|
|
bool JobIsRunning = false;
|
|
bool TaskIsRunning = false;
|
|
bool ContinueRunning = true;
|
|
|
|
void MyConnectionCallback( FMessage* CallbackMessage, void* CallbackData )
|
|
{
|
|
// Get the global handle to the system
|
|
FSwarmInterface& GSwarmInterface = FSwarmInterface::Get();
|
|
|
|
if (CallbackData == NULL)
|
|
{
|
|
printf( "NOTE: Callback data is NULL\n" );
|
|
}
|
|
// TODO: As we add additional versions, convert to a switch rather than if-else.
|
|
// For now, just use a simple if since we only have one version and a switch is
|
|
// overkill.
|
|
if (CallbackMessage->Version == VERSION_1_0)
|
|
{
|
|
switch (CallbackMessage->Type)
|
|
{
|
|
case MESSAGE_PING:
|
|
OutstandingPings--;
|
|
printf( "Ping returned!\n" );
|
|
break;
|
|
|
|
case MESSAGE_INFO:
|
|
{
|
|
printf( "*** MessageInfo:\n" );
|
|
FInfoMessage* InfoMessage = (FInfoMessage*)CallbackMessage;
|
|
_tprintf( InfoMessage->TextMessage );
|
|
printf( "\n" );
|
|
}
|
|
break;
|
|
|
|
case MESSAGE_ALERT:
|
|
{
|
|
FAlertMessage* AlertMessage = (FAlertMessage*)CallbackMessage;
|
|
printf("Alert Message received:\n");
|
|
printf("\tThreat level (%d)....", (int)(AlertMessage->AlertLevel));
|
|
switch (AlertMessage->AlertLevel)
|
|
{
|
|
case ALERT_LEVEL_INFO: printf("INFO\n"); break;
|
|
case ALERT_LEVEL_WARNING: printf("WARNING\n"); break;
|
|
case ALERT_LEVEL_ERROR: printf("ERROR\n"); break;
|
|
case ALERT_LEVEL_CRITICAL_ERROR: printf("CRITICAL ERROR\n"); break;
|
|
default: printf("*** UNKNOWN ***\n"); break;
|
|
}
|
|
printf("\tJob.............{%08x,%08x,%08x,%08x}\n", AlertMessage->JobGuid.A,
|
|
AlertMessage->JobGuid.B,
|
|
AlertMessage->JobGuid.C,
|
|
AlertMessage->JobGuid.D);
|
|
printf("\tObject..........{%08x,%08x,%08x,%08x}\n", AlertMessage->ObjectGuid.A,
|
|
AlertMessage->ObjectGuid.B,
|
|
AlertMessage->ObjectGuid.C,
|
|
AlertMessage->ObjectGuid.D);
|
|
printf("\tTypeId..........%08x\n", AlertMessage->TypeId);
|
|
_tprintf(TEXT("\t%s\n"), AlertMessage->TextMessage);
|
|
}
|
|
break;
|
|
|
|
case MESSAGE_QUIT:
|
|
ContinueRunning = false;
|
|
printf( "Quit message received!\n" );
|
|
break;
|
|
|
|
case MESSAGE_JOB_STATE:
|
|
{
|
|
FJobState* JobStateMessage = (FJobState*)CallbackMessage;
|
|
printf( "Job {%08x,%08x,%08x,%08x}\n", JobStateMessage->JobGuid.A,
|
|
JobStateMessage->JobGuid.B,
|
|
JobStateMessage->JobGuid.C,
|
|
JobStateMessage->JobGuid.D );
|
|
switch (JobStateMessage->JobState)
|
|
{
|
|
case JOB_STATE_INVALID:
|
|
printf( "is invalid" );
|
|
ContinueRunning = false;
|
|
break;
|
|
case JOB_STATE_READY:
|
|
printf( "is ready" );
|
|
break;
|
|
case JOB_STATE_RUNNING:
|
|
printf( "is now running" );
|
|
JobIsRunning = true;
|
|
break;
|
|
case JOB_STATE_COMPLETE_SUCCESS:
|
|
printf( "is complete and is successful" );
|
|
JobIsRunning = false;
|
|
OutstandingTasks = 0;
|
|
break;
|
|
case JOB_STATE_COMPLETE_FAILURE:
|
|
printf( "is complete and is a failure with an exit code of %d", JobStateMessage->JobExitCode );
|
|
JobIsRunning = false;
|
|
OutstandingTasks = 0;
|
|
break;
|
|
case JOB_STATE_KILLED:
|
|
printf( "was killed" );
|
|
JobIsRunning = false;
|
|
OutstandingTasks = 0;
|
|
break;
|
|
default:
|
|
printf( "sent an unhandled message" );
|
|
ContinueRunning = false;
|
|
break;
|
|
}
|
|
printf( "\n" );
|
|
}
|
|
break;
|
|
|
|
case MESSAGE_TASK_STATE:
|
|
{
|
|
FTaskState* TaskStateMessage = (FTaskState*)CallbackMessage;
|
|
printf( "Task {%08x,%08x,%08x,%08x}\n", TaskStateMessage->TaskGuid.A,
|
|
TaskStateMessage->TaskGuid.B,
|
|
TaskStateMessage->TaskGuid.C,
|
|
TaskStateMessage->TaskGuid.D );
|
|
printf( " " );
|
|
switch (TaskStateMessage->TaskState)
|
|
{
|
|
case JOB_TASK_STATE_INVALID:
|
|
printf( "is invalid" );
|
|
ContinueRunning = false;
|
|
break;
|
|
case JOB_TASK_STATE_ACCEPTED:
|
|
printf( "was accepted" );
|
|
TaskIsRunning = true;
|
|
break;
|
|
case JOB_TASK_STATE_REJECTED:
|
|
printf( "was rejected" );
|
|
TaskIsRunning = false;
|
|
break;
|
|
case JOB_TASK_STATE_RUNNING:
|
|
printf( "is now running" );
|
|
TaskIsRunning = true;
|
|
break;
|
|
case JOB_TASK_STATE_COMPLETE_SUCCESS:
|
|
printf( "is complete and is successful" );
|
|
OutstandingTasks--;
|
|
TaskIsRunning = false;
|
|
break;
|
|
case JOB_TASK_STATE_COMPLETE_FAILURE:
|
|
printf( "is complete and is a failure" );
|
|
OutstandingTasks--;
|
|
TaskIsRunning = false;
|
|
break;
|
|
case JOB_TASK_STATE_KILLED:
|
|
printf( "was killed" );
|
|
TaskIsRunning = false;
|
|
break;
|
|
default:
|
|
printf( "sent an unhandled message" );
|
|
ContinueRunning = false;
|
|
break;
|
|
}
|
|
printf( "\n" );
|
|
}
|
|
break;
|
|
|
|
case MESSAGE_TASK_REQUEST_RESPONSE:
|
|
{
|
|
FTaskRequestResponse* TaskRequestResponse = (FTaskRequestResponse*)CallbackMessage;
|
|
|
|
switch (TaskRequestResponse->ResponseType)
|
|
{
|
|
case RESPONSE_TYPE_RELEASE:
|
|
printf( " " );
|
|
printf( "has released us from future Tasks\n" );
|
|
JobIsRunning = false;
|
|
OutstandingTasks = 0;
|
|
break;
|
|
|
|
case RESPONSE_TYPE_RESERVATION:
|
|
{
|
|
printf( " " );
|
|
printf( "has requested a reservation for future Tasks\n" );
|
|
JobIsRunning = true;
|
|
}
|
|
break;
|
|
|
|
case RESPONSE_TYPE_SPECIFICATION:
|
|
{
|
|
FTaskSpecification* TaskSpecification = (FTaskSpecification*)TaskRequestResponse;
|
|
FGuid TaskGuid = TaskSpecification->TaskGuid;
|
|
|
|
printf( "Task {%08x,%08x,%08x,%08x}\n", TaskGuid.A,
|
|
TaskGuid.B,
|
|
TaskGuid.C,
|
|
TaskGuid.D );
|
|
printf( " " );
|
|
|
|
// Accept the Task and say that it's now running
|
|
GSwarmInterface.SendMessage( FTaskState( TaskGuid, JOB_TASK_STATE_ACCEPTED ) );
|
|
GSwarmInterface.SendMessage( FTaskState( TaskGuid, JOB_TASK_STATE_RUNNING ) );
|
|
|
|
// Do the Task (of printing the parameters out)
|
|
printf( "Parameters: %S\n", TaskSpecification->Parameters );
|
|
|
|
// Say the Task is complete
|
|
GSwarmInterface.SendMessage( FTaskState( TaskGuid, JOB_TASK_STATE_COMPLETE_SUCCESS ) );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SwarmAwareTestPathServer( _TCHAR* ExecutableName )
|
|
{
|
|
// Get the global handle to the system
|
|
FSwarmInterface& GSwarmInterface = FSwarmInterface::Get();
|
|
|
|
// Open a connection with the system
|
|
INT ErrorCode = GSwarmInterface.OpenConnection( MyConnectionCallback, NULL, SWARM_LOG_NONE );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
// Error
|
|
printf( "******** Error, OpenConnection failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
// Create the Job Guid for our work
|
|
FGuid JobGuid( 0x2, 0x23, 0x11, 0x17 );
|
|
|
|
// Start a Job and add some Tasks
|
|
JobIsRunning = true;
|
|
|
|
ErrorCode = GSwarmInterface.OpenJob( JobGuid );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, OpenJob failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
// Write out some sample data to test bi-direction file communication
|
|
{
|
|
INT FileHandle = GSwarmInterface.OpenChannel( L"ServerRandomNumbers.txt", SWARM_JOB_CHANNEL_WRITE );
|
|
if( FileHandle < 0 )
|
|
{
|
|
// Error.
|
|
printf( "******** Error, OpenChannel failed! (%d)\n", FileHandle );
|
|
}
|
|
|
|
// Some random data to a "well known file", to be read in the client
|
|
srand( ( unsigned )time( NULL ) );
|
|
int RandomNumber0 = rand();
|
|
int RandomNumber1 = rand();
|
|
int RandomNumber2 = rand();
|
|
|
|
printf( "Server writes data: %d, %d, %d\n", RandomNumber0, RandomNumber1, RandomNumber2 );
|
|
ErrorCode = GSwarmInterface.WriteChannel( FileHandle, &RandomNumber0, sizeof( RandomNumber0 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, WriteChannel error! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.WriteChannel( FileHandle, &RandomNumber1, sizeof( RandomNumber1 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, WriteChannel error! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.WriteChannel( FileHandle, &RandomNumber2, sizeof( RandomNumber2 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, WriteChannel error! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.CloseChannel( FileHandle );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseChannel error! (%d)\n", ErrorCode );
|
|
}
|
|
}
|
|
|
|
// Specify the Job
|
|
FJobSpecification NewJobSpecification( ExecutableName,
|
|
L"-swarmaware-client 2 23 11 17",
|
|
JOB_FLAG_ALLOW_REMOTE );
|
|
|
|
const _TCHAR** NewJobDependencies = new const _TCHAR*[1];
|
|
NewJobDependencies[0] = L"AgentInterface.dll";
|
|
NewJobSpecification.AddDependencies( NewJobDependencies, 1, NULL, 0 );
|
|
|
|
ErrorCode = GSwarmInterface.BeginJobSpecification( NewJobSpecification, FJobSpecification() );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, BeginJobSpecification failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
delete[] NewJobDependencies;
|
|
|
|
// Add Tasks to the Job
|
|
{
|
|
FGuid TaskGuid0( 0x23, 0x11, 0x17, 0x2 );
|
|
FTaskSpecification NewTask = FTaskSpecification( TaskGuid0, L"This is Task number 1", JOB_TASK_FLAG_USE_DEFAULTS );
|
|
|
|
const _TCHAR** NewTaskDependencies = new const _TCHAR*[1];
|
|
NewTaskDependencies[0] = L"AgentInterface.dll";
|
|
NewTask.AddDependencies( NewTaskDependencies, 1 );
|
|
|
|
ErrorCode = GSwarmInterface.AddTask( NewTask );
|
|
OutstandingTasks++;
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, AddTask1 failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
FGuid TaskGuid1( 0x11, 0x17, 0x2, 0x23 );
|
|
ErrorCode = GSwarmInterface.AddTask( FTaskSpecification( TaskGuid1, L"This is Task number 2", JOB_TASK_FLAG_USE_DEFAULTS ) );
|
|
OutstandingTasks++;
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, AddTask2 failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
FGuid TaskGuid2( 0x17, 0x2, 0x23, 0x11 );
|
|
ErrorCode = GSwarmInterface.AddTask( FTaskSpecification( TaskGuid2, L"This is Task number 3", JOB_TASK_FLAG_USE_DEFAULTS ) );
|
|
OutstandingTasks++;
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, AddTask3 failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
FGuid TaskGuid3( 0x2, 0x23, 0x11, 0x17 );
|
|
ErrorCode = GSwarmInterface.AddTask( FTaskSpecification( TaskGuid3, L"This is Task number 4", JOB_TASK_FLAG_USE_DEFAULTS ) );
|
|
OutstandingTasks++;
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, AddTask4 failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
FGuid TaskGuid4( 0x18, 0x3, 0x24, 0x12 );
|
|
ErrorCode = GSwarmInterface.AddTask( FTaskSpecification( TaskGuid4, L"This is Task number 5", JOB_TASK_FLAG_USE_DEFAULTS ) );
|
|
OutstandingTasks++;
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, AddTask5 failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
FGuid TaskGuid5( 0x3, 0x24, 0x12, 0x18 );
|
|
ErrorCode = GSwarmInterface.AddTask( FTaskSpecification( TaskGuid5, L"This is Task number 6", JOB_TASK_FLAG_USE_DEFAULTS ) );
|
|
OutstandingTasks++;
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, AddTask6 failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
FGuid TaskGuid6( 0x24, 0x12, 0x18, 0x3 );
|
|
ErrorCode = GSwarmInterface.AddTask( FTaskSpecification( TaskGuid6, L"This is Task number 7", JOB_TASK_FLAG_USE_DEFAULTS ) );
|
|
OutstandingTasks++;
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, AddTask7 failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
FGuid TaskGuid7( 0x12, 0x18, 0x3, 0x24 );
|
|
ErrorCode = GSwarmInterface.AddTask( FTaskSpecification( TaskGuid7, L"This is Task number 8", JOB_TASK_FLAG_USE_DEFAULTS ) );
|
|
OutstandingTasks++;
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, AddTask8 failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
FGuid TaskGuid8( 0x12, 0x18, 0x3, 0x25 );
|
|
ErrorCode = GSwarmInterface.AddTask( FTaskSpecification( TaskGuid8, L"This is Task number 9", JOB_TASK_FLAG_USE_DEFAULTS ) );
|
|
OutstandingTasks++;
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, AddTask9 failed! (%d)\n", ErrorCode );
|
|
}
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.EndJobSpecification();
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, EndJobSpecification failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
// Wait for all pings to return
|
|
while( ContinueRunning && ( OutstandingTasks > 0 ) )
|
|
{
|
|
// Yield
|
|
printf( "Waiting for quit signal... %d\n", OutstandingTasks );
|
|
Sleep( 1000 );
|
|
}
|
|
|
|
// Open and read the data written by the client from the "well known file"
|
|
{
|
|
INT FileHandle = GSwarmInterface.OpenChannel( L"ClientRandomNumbers.txt", SWARM_JOB_CHANNEL_READ );
|
|
if( FileHandle < 0 )
|
|
{
|
|
// Error.
|
|
printf( "******** Error, OpenChannel failed! (%d)\n", FileHandle );
|
|
}
|
|
|
|
int RandomNumber0 = 0;
|
|
int RandomNumber1 = 0;
|
|
int RandomNumber2 = 0;
|
|
|
|
ErrorCode = GSwarmInterface.ReadChannel( FileHandle, &RandomNumber0, sizeof( RandomNumber0 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, ReadChannel error! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.ReadChannel( FileHandle, &RandomNumber1, sizeof( RandomNumber1 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, ReadChannel error! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.ReadChannel( FileHandle, &RandomNumber2, sizeof( RandomNumber2 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, ReadChannel error! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
printf( "Client reads data: %d, %d, %d\n", RandomNumber0, RandomNumber1, RandomNumber2 );
|
|
|
|
ErrorCode = GSwarmInterface.CloseChannel( FileHandle );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseChannel error! (%d)\n", ErrorCode );
|
|
}
|
|
}
|
|
|
|
// End the Job
|
|
ErrorCode = GSwarmInterface.CloseJob();
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseJob failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
// Close the connection
|
|
printf( "Closing the connection and quitting\n" );
|
|
ErrorCode = GSwarmInterface.CloseConnection();
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseConnection failed! (%d)\n", ErrorCode );
|
|
}
|
|
}
|
|
|
|
void SwarmAwareTestPathClient( _TCHAR* Guid0, _TCHAR* Guid1, _TCHAR* Guid2, _TCHAR* Guid3 )
|
|
{
|
|
INT ErrorCode = SWARM_INVALID;
|
|
|
|
// Get the global handle to the system
|
|
FSwarmInterface& GSwarmInterface = FSwarmInterface::Get();
|
|
|
|
// Open a connection with the system
|
|
ErrorCode = GSwarmInterface.OpenConnection( MyConnectionCallback, NULL, SWARM_LOG_NONE );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
// Error
|
|
printf( "******** Error, OpenConnection failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
// Create the Job Guid for our work
|
|
FGuid JobGuid;
|
|
swscanf_s( Guid0, L"%08x", &JobGuid.A, sizeof( JobGuid.A ) );
|
|
swscanf_s( Guid1, L"%08x", &JobGuid.B, sizeof( JobGuid.B ) );
|
|
swscanf_s( Guid2, L"%08x", &JobGuid.C, sizeof( JobGuid.C ) );
|
|
swscanf_s( Guid3, L"%08x", &JobGuid.D, sizeof( JobGuid.D ) );
|
|
|
|
// Open and read the data written by the server from the "well known file"
|
|
{
|
|
INT FileHandle = GSwarmInterface.OpenChannel( L"ServerRandomNumbers.txt", SWARM_JOB_CHANNEL_READ );
|
|
if( FileHandle < 0 )
|
|
{
|
|
// Error.
|
|
printf( "******** Error, OpenChannel failed! (%d)\n", FileHandle );
|
|
}
|
|
|
|
int RandomNumber0 = 0;
|
|
int RandomNumber1 = 0;
|
|
int RandomNumber2 = 0;
|
|
ErrorCode = GSwarmInterface.ReadChannel( FileHandle, &RandomNumber0, sizeof( RandomNumber0 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, ReadChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.ReadChannel( FileHandle, &RandomNumber1, sizeof( RandomNumber1 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, ReadChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.ReadChannel( FileHandle, &RandomNumber2, sizeof( RandomNumber2 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, ReadChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
printf( "Client reads data: %d, %d, %d\n", RandomNumber0, RandomNumber1, RandomNumber2 );
|
|
|
|
ErrorCode = GSwarmInterface.CloseChannel( FileHandle );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseChannel error (%d)\n", ErrorCode );
|
|
}
|
|
}
|
|
|
|
// Write out some sample data to test bi-direction file communication
|
|
{
|
|
INT FileHandle = GSwarmInterface.OpenChannel( L"ClientRandomNumbers.txt", SWARM_JOB_CHANNEL_WRITE );
|
|
if( FileHandle < 0 )
|
|
{
|
|
// Error.
|
|
printf( "******** Error, OpenChannel failed! (%d)\n", FileHandle );
|
|
}
|
|
|
|
// Some random data to a "well known file", to be read in the client
|
|
srand( ( unsigned )time(NULL) );
|
|
int RandomNumber0 = rand();
|
|
int RandomNumber1 = rand();
|
|
int RandomNumber2 = rand();
|
|
|
|
printf( "Client writes data: %d, %d, %d\n", RandomNumber0, RandomNumber1, RandomNumber2 );
|
|
ErrorCode = GSwarmInterface.WriteChannel( FileHandle, &RandomNumber0, sizeof( RandomNumber0 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, WriteChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.WriteChannel( FileHandle, &RandomNumber1, sizeof( RandomNumber1 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, WriteChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.WriteChannel( FileHandle, &RandomNumber2, sizeof( RandomNumber2 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, WriteChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.CloseChannel( FileHandle );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseChannel error (%d)\n", ErrorCode );
|
|
}
|
|
}
|
|
|
|
// Test the info message
|
|
{
|
|
GSwarmInterface.SendMessage(FInfoMessage(TEXT("This is an info message test!")));
|
|
}
|
|
|
|
// Test the alert message
|
|
{
|
|
FGuid ObjectGuid;
|
|
ObjectGuid = FGuid(0,0,0,1);
|
|
GSwarmInterface.SendMessage(FAlertMessage(JobGuid, NSwarm::ALERT_LEVEL_INFO, ObjectGuid, 0x00000001, TEXT("This is an alert: INFO")));
|
|
ObjectGuid = FGuid(0,0,1,0);
|
|
GSwarmInterface.SendMessage(FAlertMessage(JobGuid, NSwarm::ALERT_LEVEL_WARNING, ObjectGuid, 0x00000002, TEXT("This is an alert: WARNING")));
|
|
ObjectGuid = FGuid(0,1,0,0);
|
|
GSwarmInterface.SendMessage(FAlertMessage(JobGuid, NSwarm::ALERT_LEVEL_ERROR, ObjectGuid, 0x00000003, TEXT("This is an alert: ERROR")));
|
|
ObjectGuid = FGuid(1,0,0,0);
|
|
GSwarmInterface.SendMessage(FAlertMessage(JobGuid, NSwarm::ALERT_LEVEL_CRITICAL_ERROR, ObjectGuid, 0x00000004, TEXT("This is an alert: CRITICAL ERROR")));
|
|
}
|
|
|
|
// Run until there is no more work to do
|
|
printf( "Starting to ask for Tasks and will keep running until we get the quit signal\n" );
|
|
JobIsRunning = true;
|
|
while( ContinueRunning && JobIsRunning )
|
|
{
|
|
// Start asking for Tasks
|
|
printf( "Sending request for task\n" );
|
|
ErrorCode = GSwarmInterface.SendMessage( FMessage( MESSAGE_TASK_REQUEST ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, SendMessage error (%d)\n", ErrorCode );
|
|
}
|
|
else
|
|
{
|
|
printf( " ...Sent\n" );
|
|
}
|
|
|
|
// Yield
|
|
Sleep( 3000 );
|
|
}
|
|
|
|
// Close the connection
|
|
printf( "Closing the connection and quitting\n" );
|
|
ErrorCode = GSwarmInterface.CloseConnection();
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseConnection failed! (%d)\n", ErrorCode );
|
|
}
|
|
}
|
|
|
|
void NonSwarmAwareTestPath( _TCHAR* ExecutableName )
|
|
{
|
|
// Get the global handle to the system
|
|
FSwarmInterface& GSwarmInterface = FSwarmInterface::Get();
|
|
|
|
// Open a connection with the system
|
|
INT ErrorCode = GSwarmInterface.OpenConnection( MyConnectionCallback, NULL, SWARM_LOG_NONE );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
// Error
|
|
printf( "******** Error, OpenConnection failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.SendMessage( FInfoMessage( L"Testing info message" ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
// Error
|
|
printf( "******** Error, SendMessage failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.CloseConnection();
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseConnection failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ContinueRunning = true;
|
|
|
|
ErrorCode = GSwarmInterface.OpenConnection( MyConnectionCallback, NULL, SWARM_LOG_NONE );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
// Error
|
|
printf( "******** Error, OpenConnection failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
// Test to see if the channel is already there
|
|
ErrorCode = GSwarmInterface.TestChannel( L"This Is A Test.txt" );
|
|
if( ErrorCode >= 0 )
|
|
{
|
|
printf( "\"This Is A Test.txt\" is already in the cache! (%d)\n", ErrorCode );
|
|
}
|
|
else
|
|
{
|
|
printf( "\"This Is A Test.txt\" is not in the cache! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
INT TestFileHandle1 = GSwarmInterface.OpenChannel( L"This Is A Test.txt", SWARM_CHANNEL_WRITE );
|
|
if( TestFileHandle1 < 0 )
|
|
{
|
|
// Error.
|
|
printf( "******** Error, OpenChannel failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
INT TestFileHandle2 = GSwarmInterface.OpenChannel( L"This Is Another Test.txt", SWARM_CHANNEL_WRITE );
|
|
if( TestFileHandle2 < 0 )
|
|
{
|
|
// Error.
|
|
printf( "******** Error, OpenChannel failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
char Data1[128] = "Any sufficiently advanced technology is indistinguishable from magic.";
|
|
ErrorCode = GSwarmInterface.WriteChannel( TestFileHandle1, Data1, sizeof( Data1 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, WriteChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
char Data2[128] = "Any sufficiently advanced technology is indistinguishable from magic... or is it?";
|
|
ErrorCode = GSwarmInterface.WriteChannel( TestFileHandle2, Data2, sizeof( Data2 ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, WriteChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.CloseChannel( TestFileHandle1 );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.CloseChannel( TestFileHandle2 );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
// Read and then write some the written data
|
|
INT TestFileHandle3 = GSwarmInterface.OpenChannel( L"This Is Another Test.txt", SWARM_CHANNEL_READ );
|
|
if( TestFileHandle3 < 0 )
|
|
{
|
|
// Error.
|
|
printf( "******** Error, OpenChannel failed! (%d)\n", TestFileHandle3 );
|
|
}
|
|
|
|
char Data3[128];
|
|
memset( Data3, 0, sizeof( Data3 ) );
|
|
int Data3ReadSize = GSwarmInterface.ReadChannel( TestFileHandle3, Data3, sizeof( Data3 ) );
|
|
if( Data3ReadSize < 0 )
|
|
{
|
|
printf( "******** Error, ReadChannel error (%d)\n", Data3ReadSize );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.CloseChannel( TestFileHandle3 );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
TestFileHandle3 = GSwarmInterface.OpenChannel( L"This Is A Third Test.txt", SWARM_CHANNEL_WRITE );
|
|
if( TestFileHandle3 < 0 )
|
|
{
|
|
// Error.
|
|
printf( "******** Error, OpenChannel failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.WriteChannel( TestFileHandle3, Data3, Data3ReadSize );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, WriteChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.CloseChannel( TestFileHandle3 );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseChannel error (%d)\n", ErrorCode );
|
|
}
|
|
|
|
// Try sending out a few messages
|
|
for( int p = 0; p < 3; p++ )
|
|
{
|
|
ErrorCode = GSwarmInterface.SendMessage( FMessage( MESSAGE_PING ) );
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Ping failed (%d)\n", ErrorCode );
|
|
}
|
|
else
|
|
{
|
|
printf( "Ping sent...\n" );
|
|
OutstandingPings++;
|
|
}
|
|
}
|
|
|
|
// Try creating a simple non-Swarm-aware Job
|
|
FGuid JobGuid0( 1, 2, 3, 4 );
|
|
printf( "Beginning Job specification (expect reject)...\n" );
|
|
FJobSpecification NewJobSpecificationReject( L"notepad.exe", L"", JOB_FLAG_USE_DEFAULTS );
|
|
ErrorCode = GSwarmInterface.OpenJob( JobGuid0 );
|
|
if( ErrorCode >= 0 )
|
|
{
|
|
ErrorCode = GSwarmInterface.BeginJobSpecification( NewJobSpecificationReject, FJobSpecification() );
|
|
if( ErrorCode >= 0 )
|
|
{
|
|
printf( "******** Error, BeginJobSpecification succeeded (and we expected failure)! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
ErrorCode = GSwarmInterface.CloseJob();
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseJob failed! (%d)\n", ErrorCode );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf( "Error, OpenJob failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
FGuid JobGuid1( 4, 3, 2, 1 );
|
|
|
|
ErrorCode = GSwarmInterface.OpenJob( JobGuid1 );
|
|
if( ErrorCode >= 0 )
|
|
{
|
|
printf( "Beginning Job specification (expect accept)...\n" );
|
|
FJobSpecification NewJobSpecificationAccept( ExecutableName, L"-nonswarmaware", JOB_FLAG_USE_DEFAULTS );
|
|
|
|
const _TCHAR** NewJobDependencies = new const _TCHAR*[1];
|
|
NewJobDependencies[0] = L"AgentInterface.dll";
|
|
NewJobSpecificationAccept.AddDependencies( NewJobDependencies, 1, NULL, 0 );
|
|
|
|
ErrorCode = GSwarmInterface.BeginJobSpecification( NewJobSpecificationAccept, FJobSpecification() );
|
|
if( ErrorCode >= 0 )
|
|
{
|
|
ErrorCode = GSwarmInterface.EndJobSpecification();
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, EndJobSpecification failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
JobIsRunning = true;
|
|
}
|
|
else
|
|
{
|
|
printf( "******** Error, BeginJobSpecification failed! (%d)\n", ErrorCode );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf( "******** Error, OpenJob failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
// Try opening a file for read that doesn't exist (should error)
|
|
INT TestFileHandle4 = GSwarmInterface.OpenChannel( L"This Is A Fourth Test.txt", SWARM_CHANNEL_READ );
|
|
if( TestFileHandle4 >= 0 )
|
|
{
|
|
// Error.
|
|
printf( "******** Error, intentional OpenChannel failure didn't fail! (%d)\n", TestFileHandle4 );
|
|
}
|
|
else
|
|
{
|
|
printf( "Error, intentional OpenChannel failure failed! (%d)\n", TestFileHandle4 );
|
|
}
|
|
|
|
// Wait for all pings to return
|
|
while( ContinueRunning && ( ( OutstandingPings > 0 ) || JobIsRunning ) )
|
|
{
|
|
// Yield
|
|
printf( "Waiting for pings to return and tasks to complete...\n" );
|
|
Sleep( 1000 );
|
|
}
|
|
|
|
// End the Job
|
|
ErrorCode = GSwarmInterface.CloseJob();
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseJob failed! (%d)\n", ErrorCode );
|
|
}
|
|
|
|
// Close the connection
|
|
printf( "Closing the connection and quitting\n" );
|
|
ErrorCode = GSwarmInterface.CloseConnection();
|
|
if( ErrorCode < 0 )
|
|
{
|
|
printf( "******** Error, CloseConnection failed! (%d)\n", ErrorCode );
|
|
}
|
|
}
|
|
|
|
int _tmain(int argc, _TCHAR* argv[])
|
|
{
|
|
// If we're only acting a simple task application, just tick and quit
|
|
if( ( argc > 1 ) && ( wcscmp( argv[1], L"-nonswarmaware" ) == 0 ) )
|
|
{
|
|
printf( "Going to sleep for a little while...\n" );
|
|
Sleep( 10000 );
|
|
printf( "Done sleeping, quitting!\n" );
|
|
exit( 0 );
|
|
}
|
|
|
|
// If we're acting like a Swarm-aware application, run that path
|
|
if( ( argc > 1 ) && ( wcscmp( argv[1], L"-swarmaware-server") == 0 ) )
|
|
{
|
|
printf( "Starting up Swarm-aware server path\n" );
|
|
SwarmAwareTestPathServer( argv[0] );
|
|
}
|
|
else if( ( argc > 1 ) && ( wcscmp( argv[1], L"-swarmaware-client" ) == 0 ) )
|
|
{
|
|
if( argc >= 5 )
|
|
{
|
|
printf( "Starting up Swarm-aware client path\n" );
|
|
SwarmAwareTestPathClient( argv[2], argv[3], argv[4], argv[5] );
|
|
}
|
|
else
|
|
{
|
|
printf( "Failed to start Swarm-aware path. Not enough parameters...\n" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf( "Starting up non-Swarm-aware path\n" );
|
|
NonSwarmAwareTestPath( argv[0] );
|
|
}
|
|
|
|
printf("\n...TestHarness complete...\n");
|
|
printf("Press any key to exit...\n");
|
|
while (!_kbhit())
|
|
{
|
|
}
|
|
return( 0 );
|
|
}
|