AReplayPlayer::AReplayPlayer(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics; // This is the default
msgpack_zone_init(&mempool, 2048);
static ConstructorHelpers::FClassFinder<AMockingVehicle> CarFinder(TEXT("/Game/Vehicle/MockingCar"));
static ConstructorHelpers::FClassFinder<AMockingVehicle> SedanFinder(TEXT("/Game/Vehicle/MockingSedan"));
static ConstructorHelpers::FClassFinder<AMockingVehicle> EmergencyFinder(TEXT("/Game/Vehicle/MockingEmergencyVehicle"));
static ConstructorHelpers::FClassFinder<AMockingVehicle> BusFinder(TEXT("/Game/Vehicle/MockingBus"));
//static ConstructorHelpers::FClassFinder<AMockingVehicle> InertiaCameraFinder(TEXT("/Game/Blueprints/InertiaCameraBP"));
static ConstructorHelpers::FObjectFinder<UMaterial> Yellow(TEXT("Material'/Game/Sedan/Materials/M_Vehicle_Sedan_yelllo.M_Vehicle_Sedan_yelllo'"));
static ConstructorHelpers::FObjectFinder<UMaterial> Blue(TEXT("Material'/Game/Sedan/Materials/M_Vehicle_Sedan.M_Vehicle_Sedan'"));
static ConstructorHelpers::FObjectFinder<UMaterial> Green(TEXT("Material'/Game/Sedan/Materials/M_Vehicle_Sedan_green.M_Vehicle_Sedan_green'"));
VehicleTypeClass.Add((uint8)EVehicleType::VT_Car, CarFinder.Class);
VehicleTypeClass.Add((uint8)EVehicleType::VT_Sedan, SedanFinder.Class);
VehicleTypeClass.Add((uint8)EVehicleType::VT_Bus, BusFinder.Class);
VehicleTypeClass.Add((uint8)EVehicleType::VT_Emergency, EmergencyFinder.Class);
TArray<UMaterial*> Materials;
Materials.Add(Yellow.Object);
Materials.Add(Blue.Object);
Materials.Add(Green.Object);
VehicleTypeMaterials.Add((uint8)EVehicleType::VT_Car, Materials);
VehicleTypeMaterials.Add((uint8)EVehicleType::VT_Sedan, Materials);
static ConstructorHelpers::FClassFinder<AActor> ArrowFinder(TEXT("/Game/Blueprints/Arrow"));
AArrow = ArrowFinder.Class;
ShowArrows = true;
ShowArrowBehaviors.Empty(0);
}
int main(void)
{
msgpack_sbuffer sbuf;
msgpack_packer pk;
msgpack_zone mempool;
msgpack_object deserialized;
/* msgpack::sbuffer is a simple buffer implementation. */
msgpack_sbuffer_init(&sbuf);
/* serialize values into the buffer using msgpack_sbuffer_write callback function. */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 3);
msgpack_pack_int(&pk, 1);
msgpack_pack_true(&pk);
msgpack_pack_str(&pk, 7);
msgpack_pack_str_body(&pk, "example", 7);
/* deserialize the buffer into msgpack_object instance. */
/* deserialized object is valid during the msgpack_zone instance alive. */
msgpack_zone_init(&mempool, 2048);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
/* print the deserialized object. */
msgpack_object_print(stdout, deserialized);
puts("");
msgpack_zone_destroy(&mempool);
msgpack_sbuffer_destroy(&sbuf);
return 0;
}
void
load_data(char *filename, load_data_function unpack_function)
{
char *save_file_name;
char *save_data;
FILE *save_file;
int len;
struct stat file_stat;
msgpack_zone *mempool;
msgpack_object deserialized;
if ((save_file_name = get_save_file_path(filename)) == NULL) {
red_log(REDD_WARNING, "get_save_file_path returned NULL");
return;
}
if (stat(save_file_name, &file_stat) != 0) {
free(save_file_name);
return;
}
if (!S_ISREG(file_stat.st_mode)) {
free(save_file_name);
return;
}
len = file_stat.st_size;
if ((save_file = fopen(save_file_name, "r")) != NULL) {
size_t bytes_read;
save_data = (char *)malloc(len);
bytes_read = fread((void *)save_data, 1, len, save_file);
fclose(save_file);
if (bytes_read != len) {
red_log(REDD_WARNING, "Failed to read data from %s", save_file_name);
free(save_file_name);
free(save_data);
return;
}
} else {
red_log(REDD_WARNING, "Failed to open %s", save_file_name);
free(save_file_name);
return;
}
mempool = (msgpack_zone *)malloc(sizeof(msgpack_zone));
msgpack_zone_init(mempool, 4096);
msgpack_unpack(save_data, len, NULL, mempool, &deserialized);
unpack_function(deserialized);
free(save_file_name);
save_file_name = NULL;
free(save_data);
save_data = NULL;
msgpack_zone_destroy(mempool);
free(mempool);
mempool = NULL;
}
/// output MessagePack sbuffer to stream in text format
static void log_text_sbuffer(FILE *stream, msgpack_sbuffer *msg) {
// deserialize sbuffer to object
msgpack_zone mempool;
msgpack_zone_init(&mempool, 1024);
msgpack_object deserialized;
msgpack_unpack(msg->data, msg->size, NULL, &mempool, &deserialized);
// now output the message object
log_text(stream, &deserialized);
// and free up memory
msgpack_zone_destroy(&mempool);
}
void unit_message_is_response(UNUSED(void **state))
{
msgpack_sbuffer sbuf;
msgpack_packer pk;
msgpack_zone mempool;
msgpack_object deserialized;
msgpack_sbuffer_init(&sbuf);
msgpack_zone_init(&mempool, 2048);
/* positiv test */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_pack_uint8(&pk, 0);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_true(message_is_response(&deserialized));
msgpack_sbuffer_clear(&sbuf);
/* wrong type test */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 0);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint8(&pk, 1);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_false(message_is_response(&deserialized));
msgpack_sbuffer_clear(&sbuf);
/* no array test */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_uint8(&pk, 1);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_false(message_is_response(&deserialized));
msgpack_sbuffer_clear(&sbuf);
/* NULL test */
assert_false(message_is_response(NULL));
msgpack_sbuffer_clear(&sbuf);
msgpack_zone_destroy(&mempool);
msgpack_sbuffer_destroy(&sbuf);
}
static void
on_response(msgxchng_response_t *res, int status)
{
if (status == RED_ERR)
exit(1);
msgpack_zone mempool;
msgpack_zone_init(&mempool, 4096);
msgpack_object deserialized;
msgpack_unpack(res->data, res->data_len, NULL, &mempool, &deserialized);
int success = 0;
if (deserialized.type == MSGPACK_OBJECT_MAP) {
msgpack_object_kv* p = deserialized.via.map.ptr;
msgpack_object_kv* const pend = deserialized.via.map.ptr + deserialized.via.map.size;
for (; p < pend; ++p) {
if (p->key.type == MSGPACK_OBJECT_RAW && p->val.type == MSGPACK_OBJECT_RAW) {
if (!strncmp(p->key.via.raw.ptr, "return", p->key.via.raw.size)) {
if (!strncmp(p->val.via.raw.ptr, "success", p->val.via.raw.size))
success = 1;
else
success = 0;
} else if (!strncmp(p->key.via.raw.ptr, "error", p->key.via.raw.size)) {
if (!config.no_output) fprintf(stderr, "red: %s\n", p->val.via.raw.ptr);
}
}
}
}
clean_msgxchng_response(res);
free(res);
if (!success)
exit(1);
}
void unit_message_deserialize_response(UNUSED(void **state))
{
struct api_error error = ERROR_INIT;
msgpack_sbuffer sbuf;
msgpack_packer pk;
msgpack_zone mempool;
msgpack_object deserialized;
struct message_response response;
msgpack_sbuffer_init(&sbuf);
msgpack_zone_init(&mempool, 2048);
/* positiv test */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
free_params(response.params);
/* wrong type type */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_nil(&pk);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong type */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 0);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong msgid */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_int(&pk, -1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong msgid value*/
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, UINT32_MAX);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong nil */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong params */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_nil(&pk);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* null input params */
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
NULL));
assert_int_not_equal(0, message_deserialize_response(&response, NULL,
&error));
assert_int_not_equal(0, message_deserialize_response(NULL, &deserialized,
&error));
msgpack_zone_destroy(&mempool);
msgpack_sbuffer_destroy(&sbuf);
}
void msgpack_rpc_helpers_init(void)
{
msgpack_zone_init(&zone, 0xfff);
msgpack_sbuffer_init(&sbuffer);
}
void trigger(void *cvoid,
zctx_t * context,
void * control) {
triggerconfig_t * c = (triggerconfig_t*) cvoid;
//set up msgpack stuff
zclock_log("watch_port started!");
msgpack_zone mempool;
msgpack_zone_init(&mempool, 2048);
// TODO
char * user_id = "17";
// TODO get broker in somehow
char * broker = "tcp://au.ninjablocks.com:5773";
mdcli_t * client = mdcli_new(broker, 1); //VERBOSE
triggermemory_t trigger_memory;
msgpack_object * addins_obj = parse_msgpack(&mempool, c->addins);
if(!parse_addins(addins_obj, &trigger_memory)) {
//bad message
zclock_log("bad trigger definition");
msgpack_object_print(stdout, *addins_obj);
send_sync("bad trigger", control);
return;
}
zclock_log("Creating trigger: target %s, rule_id %s, name %s",
c->target_worker, c->rule_id, c->trigger_name);
dump_trigger(&trigger_memory);
triggerfunction trigger_func;
if(!(trigger_func = find_trigger(c->channel, c->trigger_name))) {
zclock_log("no trigger found for channel %s, trigger %s",
c->channel, c->trigger_name);
send_sync("no such trigger", control);
return;
}
void * line = zsocket_new(context, ZMQ_SUB);
// what line are we on?
// this comes in the addins.
char * linesocket = to_linesocket(trigger_memory.line_id);
zclock_log("trigger is connecting to listen on %s", linesocket);
zsocket_connect(line, linesocket);
zsockopt_set_unsubscribe(line, "");
zsockopt_set_subscribe(line, "VALUE");
recv_sync("ping", control);
send_sync("pong", control);
zmq_pollitem_t items [] = {
{ line, 0, ZMQ_POLLIN, 0 },
{ control, 0, ZMQ_POLLIN, 0 }
};
while(1) {
// listen on control and line
zmq_poll (items, 2, -1);
if (items[1].revents & ZMQ_POLLIN) {
zclock_log("rule %s received message on control pipe", c->rule_id);
// control message
// really only expecting DESTROY
zmsg_t * msg = zmsg_recv(control);
char * str = zmsg_popstr(msg);
zmsg_destroy(&msg);
if (strcmp("Destroy", str) == 0) {
zclock_log("rule %s will quit on request", c->rule_id);
free(str);
send_sync("ok", control);
zclock_log("rule %s quitting on request", c->rule_id);
break;
} else {
zclock_log("unexpected command %s for rule %s", str, c->rule_id);
free(str);
send_sync("ok", control);
}
}
if (items[0].revents & ZMQ_POLLIN) {
// serial update
zmsg_t * msg = zmsg_recv(line);
zframe_t * cmd = zmsg_pop(msg);
if(zframe_streq(cmd, "CHANNEL_CHANGE")) {
// TODO
// must have been dormant to have gotten this
char * new_channel = zmsg_popstr(msg);
if(strcmp(c->channel, new_channel) == 0) {
// oh, happy day! We're relevant again.
// reactivate and start looking at reset levels.
zclock_log("line %d: changed channel from %s to %s: trigger coming back to life", trigger_memory.line_id, c->channel, new_channel);
zsockopt_set_subscribe(line, "VALUE");
zsockopt_set_unsubscribe(line, "CHANNEL_CHANGE");
}
free(new_channel);
} else if (zframe_streq(cmd, "VALUE")) {
zframe_t * vframe = zmsg_pop(msg);
int value;
memcpy(&value, zframe_data(vframe), sizeof(int));
char * update_channel = zmsg_popstr(msg);
if(strcmp(c->channel, update_channel) != 0) {
// channel changed, go dormant
// this is legit according to my tests at
// https://gist.github.com/2042350
zclock_log("line %d: changed channel from %s to %s: trigger going dormant", trigger_memory.line_id, c->channel, update_channel);
zsockopt_set_subscribe(line, "CHANNEL_CHANGE");
zsockopt_set_unsubscribe(line, "VALUE");
}
else if(trigger_func(&trigger_memory, value)) {
send_trigger(client, c->target_worker, c->rule_id, value, user_id);
}
free(update_channel);
} else {
// shouldn't ever happen.
zclock_log("shouldn't have received command %s\n", zframe_strdup(cmd));
}
zmsg_destroy(&msg);
zframe_destroy(&cmd);
}
}
msgpack_zone_destroy(&mempool);
}