static void test_extend(void)
{
json_t *array1, *array2, *five, *seven;
int i;
array1 = json_array();
array2 = json_array();
five = json_integer(5);
seven = json_integer(7);
if(!array1 || !array2)
fail("unable to create array");
if(!five || !seven)
fail("unable to create integer");
for(i = 0; i < 10; i++) {
if(json_array_append(array1, five))
fail("unable to append");
}
for(i = 0; i < 10; i++) {
if(json_array_append(array2, seven))
fail("unable to append");
}
if(json_array_size(array1) != 10 || json_array_size(array2) != 10)
fail("array size is invalid after appending");
if(json_array_extend(array1, array2))
fail("unable to extend");
for(i = 0; i < 10; i++) {
if(json_array_get(array1, i) != five)
fail("invalid array contents after extending");
}
for(i = 10; i < 20; i++) {
if(json_array_get(array1, i) != seven)
fail("invalid array contents after extending");
}
json_decref(five);
json_decref(seven);
json_decref(array1);
json_decref(array2);
}
int plugin_init(HMODULE hMod)
{
json_t *funcs_new = json_object();
int ret = GetExportedFunctions(funcs_new, hMod);
if(!funcs) {
funcs = json_object();
}
if(!mod_funcs) {
mod_funcs = json_object();
}
if(!ret) {
json_t *mod_funcs_new = mod_func_build(funcs_new);
const char *key;
json_t *val;
mod_func_run(mod_funcs_new, "init", NULL);
mod_func_run(mod_funcs_new, "detour", NULL);
json_object_foreach(mod_funcs_new, key, val) {
json_t *funcs_old = json_object_get_create(mod_funcs, key, JSON_ARRAY);
json_array_extend(funcs_old, val);
}
//native json_array_extend(Handle:hArray, Handle:hOther);
static cell_t Native_json_array_extend(IPluginContext *pContext, const cell_t *params) {
HandleError err;
HandleSecurity sec;
sec.pOwner = NULL;
sec.pIdentity = myself->GetIdentity();
// Param 1: hArray
json_t *object;
Handle_t hndlObject = static_cast<Handle_t>(params[1]);
if ((err=g_pHandleSys->ReadHandle(hndlObject, htJanssonObject, &sec, (void **)&object)) != HandleError_None)
{
return pContext->ThrowNativeError("Invalid <Array> handle %x (error %d)", hndlObject, err);
}
// Param 2: hValue
json_t *other;
Handle_t hndlOther = static_cast<Handle_t>(params[2]);
if ((err=g_pHandleSys->ReadHandle(hndlOther, htJanssonObject, &sec, (void **)&other)) != HandleError_None)
{
return pContext->ThrowNativeError("Invalid <Array> handle %x (error %d)", hndlObject, err);
}
return (json_array_extend(object, other) == 0);
}
static void *perf_log_thread(void *unused) {
json_t *samples = NULL;
char **envp;
json_t *perf_cmd;
int64_t sample_batch;
unused_parameter(unused);
w_set_thread_name("perflog");
// Prep some things that we'll need each time we run a command
{
uint32_t env_size;
w_ht_t *envpht = w_envp_make_ht();
char *statedir = dirname(strdup(watchman_state_file));
w_envp_set_cstring(envpht, "WATCHMAN_STATE_DIR", statedir);
w_envp_set_cstring(envpht, "WATCHMAN_SOCK", get_sock_name());
envp = w_envp_make_from_ht(envpht, &env_size);
}
perf_cmd = cfg_get_json(NULL, "perf_logger_command");
if (json_is_string(perf_cmd)) {
perf_cmd = json_pack("[O]", perf_cmd);
}
if (!json_is_array(perf_cmd)) {
w_log(
W_LOG_FATAL,
"perf_logger_command must be either a string or an array of strings\n");
}
sample_batch =
cfg_get_int(NULL, "perf_logger_command_max_samples_per_call", 4);
while (true) {
pthread_mutex_lock(&perf_log_lock);
if (!perf_log_samples) {
pthread_cond_wait(&perf_log_cond, &perf_log_lock);
}
samples = perf_log_samples;
perf_log_samples = NULL;
pthread_mutex_unlock(&perf_log_lock);
if (samples) {
while (json_array_size(samples) > 0) {
int i = 0;
json_t *cmd = json_array();
posix_spawnattr_t attr;
posix_spawn_file_actions_t actions;
pid_t pid;
char **argv = NULL;
json_array_extend(cmd, perf_cmd);
while (i < sample_batch && json_array_size(samples) > 0) {
char *stringy = json_dumps(json_array_get(samples, 0), 0);
json_array_append(cmd, typed_string_to_json(stringy, W_STRING_MIXED));
free(stringy);
json_array_remove(samples, 0);
i++;
}
argv = w_argv_copy_from_json(cmd, 0);
if (!argv) {
char *dumped = json_dumps(cmd, 0);
w_log(W_LOG_FATAL, "error converting %s to an argv array\n", dumped);
}
posix_spawnattr_init(&attr);
#ifdef POSIX_SPAWN_CLOEXEC_DEFAULT
posix_spawnattr_setflags(&attr, POSIX_SPAWN_CLOEXEC_DEFAULT);
#endif
posix_spawn_file_actions_init(&actions);
posix_spawn_file_actions_addopen(&actions, STDIN_FILENO, "/dev/null",
O_RDONLY, 0666);
posix_spawn_file_actions_addopen(&actions, STDOUT_FILENO, "/dev/null",
O_WRONLY, 0666);
posix_spawn_file_actions_addopen(&actions, STDERR_FILENO, "/dev/null",
O_WRONLY, 0666);
if (posix_spawnp(&pid, argv[0], &actions, &attr, argv, envp) == 0) {
// There's no sense waiting here, because w_reap_children is called
// by the reaper thread.
} else {
int err = errno;
w_log(W_LOG_ERR, "failed to spawn %s: %s\n", argv[0],
strerror(err));
}
posix_spawnattr_destroy(&attr);
posix_spawn_file_actions_destroy(&actions);
free(argv);
json_decref(cmd);
}
json_decref(samples);
}
}
return NULL;
}
void PerfLogThread::loop() {
json_ref samples;
char **envp;
json_ref perf_cmd;
int64_t sample_batch;
w_set_thread_name("perflog");
// Prep some things that we'll need each time we run a command
{
uint32_t env_size;
auto envpht = w_envp_make_ht();
char *statedir = dirname(strdup(watchman_state_file));
w_envp_set_cstring(envpht, "WATCHMAN_STATE_DIR", statedir);
w_envp_set_cstring(envpht, "WATCHMAN_SOCK", get_sock_name());
envp = w_envp_make_from_ht(envpht, &env_size);
}
perf_cmd = cfg_get_json("perf_logger_command");
if (json_is_string(perf_cmd)) {
perf_cmd = json_array({perf_cmd});
}
if (!json_is_array(perf_cmd)) {
w_log(
W_LOG_FATAL,
"perf_logger_command must be either a string or an array of strings\n");
}
sample_batch = cfg_get_int("perf_logger_command_max_samples_per_call", 4);
while (!w_is_stopping()) {
{
auto wlock = samples_.wlock();
if (!*wlock) {
cond_.wait(wlock.getUniqueLock());
}
samples = nullptr;
std::swap(samples, *wlock);
}
if (samples) {
while (json_array_size(samples) > 0) {
int i = 0;
auto cmd = json_array();
posix_spawnattr_t attr;
posix_spawn_file_actions_t actions;
pid_t pid;
char **argv = NULL;
json_array_extend(cmd, perf_cmd);
while (i < sample_batch && json_array_size(samples) > 0) {
char *stringy = json_dumps(json_array_get(samples, 0), 0);
if (stringy) {
json_array_append_new(
cmd, typed_string_to_json(stringy, W_STRING_MIXED));
free(stringy);
}
json_array_remove(samples, 0);
i++;
}
argv = w_argv_copy_from_json(cmd, 0);
if (!argv) {
char *dumped = json_dumps(cmd, 0);
w_log(W_LOG_FATAL, "error converting %s to an argv array\n", dumped);
}
posix_spawnattr_init(&attr);
#ifdef POSIX_SPAWN_CLOEXEC_DEFAULT
posix_spawnattr_setflags(&attr, POSIX_SPAWN_CLOEXEC_DEFAULT);
#endif
posix_spawn_file_actions_init(&actions);
posix_spawn_file_actions_addopen(&actions, STDIN_FILENO, "/dev/null",
O_RDONLY, 0666);
posix_spawn_file_actions_addopen(&actions, STDOUT_FILENO, "/dev/null",
O_WRONLY, 0666);
posix_spawn_file_actions_addopen(&actions, STDERR_FILENO, "/dev/null",
O_WRONLY, 0666);
if (posix_spawnp(&pid, argv[0], &actions, &attr, argv, envp) == 0) {
int status;
while (waitpid(pid, &status, 0) != pid) {
if (errno != EINTR) {
break;
}
}
} else {
int err = errno;
w_log(W_LOG_ERR, "failed to spawn %s: %s\n", argv[0],
strerror(err));
}
posix_spawnattr_destroy(&attr);
posix_spawn_file_actions_destroy(&actions);
free(argv);
}
}
}
}
bool TrafficNetwork::saveToFile(const string out_prefix, bool newWeek){
bool everythingOK = true;
int metric = KPH; //save in KPH such that it can be used by external tool (and be human readable)
std::vector<long> nIds;
long crtId;
char crtType;
string out_fileName = (out_prefix+"_roads_stats.json");
json_t *root = NULL;
if(firstSaved){
if(fileName != ""){
json_error_t error;
root = json_load_file(fileName.c_str(), 0, &error);
if(!root){
std::cout<<std::endl<<"WARNING: while opening "<<fileName<<" at line "<<error.line<<" - "<<error.text<<std::endl;
root= NULL;
}
if(!json_is_object(root)){
std::cout<<std::endl<<"WARNING: input file "<<fileName<<" has not the correct structure - expected root to be an object"<<std::endl;
json_decref(root);
root = NULL;
}
if(!root){
std::cout<<"File "<<fileName<<" could not be using during saving process"<<std::endl<<"\t --> reverting to saving network based on stored data (possibility for loss of positional infos)"<<std::endl;
}
}
if(!root){
root = json_object();
if ( root ) {
json_object_set_new(root, "metric" ,json_integer(metric));
json_t *_nodes = json_array();
json_t *_roads = json_array();
for(NodeVec::iterator it= nodes.begin() ; it!=nodes.end(); ++it){
json_t * _node = json_object();
crtId = (*it)->getId();
crtType = (*it)->getType();
json_object_set_new(_node,"id",json_integer(crtId));
json_object_set_new(_node,"type",json_integer(crtType));
json_array_append_new(_nodes,_node);
nIds = (*it)->getNeighborsId();
for(std::vector<long>::iterator jt = nIds.begin(); jt != nIds.end(); ++jt){
Road r = *((*it)->roadTo(*jt));
json_t * _road = json_object();
json_object_set_new(_road,"name",json_string(r.getName().c_str()));
json_object_set_new(_road,"startId",json_integer(crtId));
json_object_set_new(_road,"endId",json_integer(r.getEndPoint()->getId()));
json_object_set_new(_road,"speedLimit",json_integer(r.getSpeedLimit()*3.6)); //x3.6 to go from MPS to KPH
json_object_set_new(_road,"length",json_real(r.getLength()/1000)); // /1000 to go from M to K
json_object_set_new(_road,"nbBands",json_integer(r.getNbBands()));
json_array_append_new(_roads,_road);
}
}
json_object_set_new(root, "nodes" ,_nodes);
json_object_set_new(root, "roads" ,_roads);
}else{
std::cout<<"ERROR: Could not create 'root' during saving process"<<std::endl;
return false;
}
}
}else{
json_error_t error;
root = json_load_file(out_fileName.c_str(), 0, &error);
if(!root){
std::cout<<std::endl<<"ERROR: while opening "<<out_fileName<<" at line "<<error.line<<" - "<<error.text<<std::endl;
root= NULL;
return false;
}
if(!json_is_object(root)){
std::cout<<std::endl<<"ERROR: input file "<<fileName<<" has not the correct structure - expected root to be an object"<<std::endl;
json_decref(root);
root = NULL;
return false;
}
}
json_t *roadsInfos;
if(monitered){
bool first = false;
if(firstSaved){
roadsInfos = json_array();
int nbRoads = json_array_size(json_object_get(root,"roads"));
for(int i = 0; i < nbRoads; i++){
json_array_append_new(roadsInfos,json_object());
}
json_object_set(root,"roadsInfos",roadsInfos);
json_object_set_new(root,"timePrecision",json_integer(TIME_PRECISION));
json_object_set_new(root,"time_index",json_integer(0));
json_object_set_new(root,"driversCount_index",json_integer(1));
firstSaved = false;
first = true;
}else
roadsInfos = json_object_get(root,"roadsInfos");
json_t *infos;
for(NodeVec::iterator it= nodes.begin() ; it!=nodes.end(); ++it){
nIds = (*it)->getNeighborsId();
for(std::vector<long>::iterator jt = nIds.begin(); jt != nIds.end(); ++jt){
Road* r = ((*it)->roadTo(*jt));
infos = r->getMonitor()->getInfos();
if(first){
json_object_update(json_array_get(roadsInfos,r->getId()),infos);
}else{
json_array_extend(json_object_get(json_array_get(roadsInfos,r->getId()),"data"),json_object_get(infos,"data"));
}
r->getMonitor()->resetInfos(newWeek);
json_object_clear(infos);
json_decref(infos);
}
}
}
//actually save
if(!(json_dump_file(root,out_fileName.c_str(),JSON_COMPACT) == 0)){
//if(!(json_dump_file(root,out_fileName.c_str(),JSON_INDENT(2)) == 0)){ //<== to have pretty JSON file
everythingOK = false;
std::cout<< "Could not open file : "<<out_fileName << " to write down network "<< name <<std::endl;
}
if(monitered){
json_array_clear(roadsInfos);
}
json_object_clear(root);
json_decref(root);
if(newWeek){
firstSaved = true;
}
return everythingOK;
}
int ast_json_array_extend(struct ast_json *array, struct ast_json *tail)
{
return json_array_extend((json_t *)array, (json_t *)tail);
}
int la_codec_array_extend(la_codec_value_t *array, la_codec_value_t *other_array)
{
return json_array_extend((json_t*) array, (json_t*) other_array);
}
