int main(int argc, char ** argv) { if (argc != 3) { fprintf(stderr, "Wrong number of arguments, pass one action type and a namespace\n"); return 1; } rclcpp::init(argc, argv); auto start = std::chrono::steady_clock::now(); std::string action = argv[1]; std::string namespace_ = argv[2]; auto node = rclcpp::Node::make_shared(std::string("test_action_server_") + action, namespace_); rclcpp_action::ServerBase::SharedPtr server; if (action == "Fibonacci") { server = receive_goals<test_msgs::action::Fibonacci>( node, action, generate_expected_fibonacci_goals(node->get_logger())); } else if (action == "NestedMessage") { server = receive_goals<test_msgs::action::NestedMessage>( node, action, generate_expected_nested_message_goals(node->get_logger())); } else { fprintf(stderr, "Unknown action type '%s'\n", action.c_str()); return 1; } rclcpp::spin(node); auto end = std::chrono::steady_clock::now(); std::chrono::duration<float> diff = (end - start); printf("replied for %f seconds\n", diff.count()); return should_fail ? 1 : 0; }
////////////////////////////////////////////////////////////////////////// /// Create an instance of a given type. /// Used internally to create instances of various settings types. /// /// @param type the type to create /// @param context the context to use /// @return a new instance of given type. /// /// @author mickem settings::instance_raw_ptr NSCSettingsImpl::create_instance(std::wstring key) { net::wurl url = net::parse(key); if (url.protocol.empty()) { url = net::parse(key + _T("://")); get_logger()->debug(__FILE__, __LINE__, _T("No driver specified attemtping to fake one: ") + url.to_string()); } get_logger()->debug(__FILE__, __LINE__, _T("Creating instance for: ") + url.to_string()); if (url.host.empty() && url.path.empty()) key = _T(""); #ifdef WIN32 if (url.protocol == _T("old")) { old_ = true; if (key.empty()) key = DEFAULT_CONF_OLD_LOCATION; return settings::instance_raw_ptr(new settings::OLDSettings(this, key)); } if (url.protocol == _T("registry")) { if (key.empty()) key = DEFAULT_CONF_REG_LOCATION; return settings::instance_raw_ptr(new settings::REGSettings(this, key)); } #endif if (url.protocol == _T("ini")) { if (key.empty()) key = DEFAULT_CONF_INI_LOCATION; return settings::instance_raw_ptr(new settings::INISettings(this, key)); } if (url.protocol == _T("dummy")) { return settings::instance_raw_ptr(new settings::settings_dummy(this, key)); } if (url.protocol == _T("http")) { return settings::instance_raw_ptr(new settings::settings_http(this, key)); } throw settings::settings_exception(_T("Undefined settings protocol: ") + url.protocol); }
void ensure_directory_for_file(const std::string path) { char *cmd = (char *) alloca(path.size() + 20); sprintf(cmd, "mkdir -p $(dirname %s)", path.c_str()); get_logger().log_line("Making directory for " + path, DEBUG); system(cmd); }
BOOST_FOREACH(std::string k, order) { if (context_exists(k)) { get_logger()->debug("settings", __FILE__, __LINE__, "Activating: " + k); set_instance(k); return; } }
LoggerSPtr LoggerFactory::get_logger(const char* name, bool only_defined) const { if (!name) { return global_logger(); } std::string logger(name); return get_logger(logger, only_defined); }
void session::read_file(const key &id, const std::string &file, uint64_t offset, uint64_t size) { transform(id); session sess = clone(); sess.set_exceptions_policy(throw_at_get); read_result_entry result = sess.read_data(id, offset, size).get_one(); dnet_io_attr *io = result.io_attribute(); int err; file_descriptor fd(open(file.c_str(), O_RDWR | O_CREAT | O_CLOEXEC, 0644)); if (fd.fd() < 0) { err = -errno; throw_error(err, id, "Failed to open read completion file: '%s'", file.c_str()); } err = pwrite(fd.fd(), result.file().data(), result.file().size(), offset); if (err <= 0) { err = -errno; throw_error(err, id, "Failed to write data into completion file: '%s'", file.c_str()); } BH_LOG(get_logger(), DNET_LOG_NOTICE, "%s: read completed: file: '%s', offset: %llu, size: %llu, status: %d.", dnet_dump_id(&id.id()), file, offset, uint64_t(io->size), int(result.command()->status)); }
int test(void) { int result = 0; logger_t log = get_logger(info); log(error, "hello world"); assert(logger_data() != NULL); assert(!result && !strcmp(logger_data() + 26, " [ERROR] {test} hello world\n")); return result; }
result:: result(logger *logger, void *dso_handle, tempdir *tempdir_) : log_user (logger), m_dso_handle (dso_handle), m_tempdir (tempdir_) { JIT_LOG_SCOPE (get_logger ()); }
void FileSet::add_object(ObjectFile* object) { if (!add_file(object)) { return; } get_logger().log_line("Found object file: " + object->get_path(), DEBUG); m_objects.insert(object); }
void FileSet::add_library(LibraryFile* f) { if (!add_file(f)) { return; } get_logger().log_line("Found library: " + f->get_path(), DEBUG); m_libraries.insert(f); }
void FileSet::add_source(SourceFile* f) { if (!add_file(f)) { return; } get_logger().log_line("Found source: " + f->get_path(), DEBUG); m_sources.insert(f); }
void FileSet::add_header(HeaderFile* f) { if (!add_file(f)) { return; } get_logger().log_line("Found header: " + f->get_path(), DEBUG); m_headers.insert(f); }
lib_t *lib_create(const char *dbfile, const char *libdir) { lib_t *lib=malloc(sizeof(lib_t)); if(!lib) return NULL; lib->watch=watch_create(lib); if(!lib->watch) { error(ll, "failed to create watcher."); goto err; } lib->watch->event=lib_watch_event; empty=string_create_unique(""); ll=get_logger("lib"); lib->entries=chunked_list_create(512, sizeof(lib_entry), &lib_entry_destructor); if(!lib->entries) { error(ll, "failed to allocate lib."); goto err; } int s=strlen(libdir); if(libdir[s-1]!='/') { char *tmp=malloc(s+2); strcpy(tmp, libdir); tmp[s++]='/'; tmp[s]=0; libdir=tmp; } else libdir=strdup(libdir); lib->base_path=libdir; lib->base_path_size=s; filecount=0; lib->dbfile=strdup(dbfile); lib_read(lib); // pthread_create(&lib->check_thread, NULL, check_lib, lib); // pthread_join(lib->check_thread, NULL); check_lib(lib); return lib; err: if(lib) { if(lib->entries) chunked_list_destroy(lib->entries); if(lib->watch) watch_destroy(lib->watch); free(lib); } return NULL; }
logging::trace_helper::trace_helper(std::string class_name, const char* fun_name, const char* file_name, int line_num, const std::string& msg) : m_class(std::move(class_name)), m_fun_name(fun_name) , m_file_name(file_name), m_line_num(line_num) { get_logger()->log("TRACE", m_class.c_str(), fun_name, file_name, line_num, "ENTRY " + msg); }
void set_log_level(LogLevel l) { // snap to max level if (l > IMP_HAS_LOG) { l = LogLevel(IMP_HAS_LOG); } #if IMP_BASE_HAS_LOG4CXX try { switch (l) { case PROGRESS: case SILENT: get_logger()->setLevel(log4cxx::Level::getOff()); break; case WARNING: get_logger()->setLevel(log4cxx::Level::getWarn()); break; case TERSE: get_logger()->setLevel(log4cxx::Level::getInfo()); break; case VERBOSE: get_logger()->setLevel(log4cxx::Level::getDebug()); break; case MEMORY: get_logger()->setLevel(log4cxx::Level::getTrace()); break; case DEFAULT: case ALL_LOG: default: IMP_WARN("Unknown log level " << boost::lexical_cast<std::string>(l)); } } catch (log4cxx::helpers::Exception &) { IMP_THROW("Invalid log level", ValueException); } #else IMP_USAGE_CHECK(l >= SILENT && l < ALL_LOG, "Setting log to invalid level: " << l); #endif IMP_OMP_PRAGMA(critical(imp_log)) if (internal::log_level != l) { internal::log_level = l; } }
void session::write_file(const key &id, const std::string &file, uint64_t local_offset, uint64_t offset, uint64_t size) { transform(id); session sess = clone(); sess.set_exceptions_policy(throw_at_wait); int err; file_descriptor fd(open(file.c_str(), O_RDONLY | O_LARGEFILE | O_CLOEXEC)); if (fd.fd() < 0) { err = -errno; throw_error(err, id, "Failed to open read completion file '%s'", file.c_str()); } struct stat stat; memset(&stat, 0, sizeof(stat)); err = fstat(fd.fd(), &stat); if (err) { err = -errno; throw_error(err, id, "Failed to stat to be written file '%s'", file.c_str()); } if (local_offset >= (uint64_t)stat.st_size) { BH_LOG(get_logger(), DNET_LOG_NOTICE, "%s: File is already uploaded: '%s'", dnet_dump_id(&id.id()), file); return; } if (!size || size + local_offset >= (uint64_t)stat.st_size) size = stat.st_size - local_offset; dnet_io_control ctl; memset(&ctl, 0, sizeof(struct dnet_io_control)); ctl.data = NULL; ctl.fd = fd.fd(); ctl.local_offset = local_offset; memcpy(ctl.io.id, id.id().id, DNET_ID_SIZE); memcpy(ctl.io.parent, id.id().id, DNET_ID_SIZE); ctl.io.size = size; ctl.io.offset = offset; ctl.io.timestamp.tsec = stat.st_mtime; ctl.io.timestamp.tnsec = 0; ctl.id = id.id(); write_data(ctl).wait(); }
result::~result() { JIT_LOG_SCOPE (get_logger ()); dlclose (m_dso_handle); /* Responsibility for cleaning up the tempdir (including "fake.so" within the filesystem) might have been handed to us by the playback::context, so that the cleanup can be delayed (see PR jit/64206). If so, clean it up now. */ delete m_tempdir; }
RunResult run_system_cmd(const std::string &str, bool need_output) { std::string cmd_file = get_config().get_tmp_cmd_file(); get_logger().log_line("Saving cmd to '" + cmd_file + "': " + str, INFO); cccfg::ensure_directory_for_file(cmd_file); { std::ofstream c{cmd_file}; c << str << std::endl; } cmd_file += ".output"; int status_code; { char *cmd = (char *) alloca (10 + str.size() + 2 * cmd_file.size()); sprintf(cmd, "%s 2>%s 1>%s", str.c_str(), cmd_file.c_str(), cmd_file.c_str()); status_code = system(cmd); } std::string output; if (need_output) { std::stringstream buffer; std::ifstream in_file(cmd_file); std::string line; while (std::getline(in_file, line)) { buffer << line << "\n"; } output = buffer.str(); get_logger().log_external_cmd(output); } return RunResult(status_code, output); }
////////////////////////////////////////////////////////////////////////// /// Boot the settings subsystem from the given file (boot.ini). /// /// @param file the file to use when booting. /// /// @author mickem void NSCSettingsImpl::boot(std::string key) { std::list<std::string> order; if (!key.empty()) { order.push_back(key); } boot_ = provider_->expand_path(BOOT_CONF_LOCATION); if (boost::filesystem::is_regular_file(boot_)) { get_logger()->debug("settings", __FILE__, __LINE__, "Boot.ini found in: " + boot_.string()); for (int i=0;i<20;i++) { std::string v = get_boot_string("settings", strEx::s::xtos(i), ""); if (!v.empty()) order.push_back(expand_context(v)); } } if (order.size() == 0) { get_logger()->debug("settings", __FILE__, __LINE__, "No entries found looking in (adding default): " + boot_.string()); order.push_back(DEFAULT_CONF_OLD_LOCATION); order.push_back(DEFAULT_CONF_INI_LOCATION); } std::string boot_order; BOOST_FOREACH(const std::string &k, order) { strEx::append_list(boot_order, k, ", "); }
/** * called after the request is sent * * @param write_error error status from the last write operation * @param bytes_written number of bytes sent by the last write operation */ virtual void handle_write(const boost::system::error_code& write_error, std::size_t bytes_written) { logger log_ptr(get_logger()); if (! write_error) { // request sent OK if (sending_chunked_message()) { PION_LOG_DEBUG(log_ptr, "Sent HTTP request chunk of " << bytes_written << " bytes"); clear(); } else { PION_LOG_DEBUG(log_ptr, "Sent HTTP request of " << bytes_written << " bytes"); } } finished_writing(write_error); }
////////////////////////////////////////////////////////////////////////// /// Boot the settings subsystem from the given file (boot.ini). /// /// @param file the file to use when booting. /// /// @author mickem void NSCSettingsImpl::boot(std::wstring key) { std::list<std::wstring> order; if (!key.empty()) { order.push_back(key); } boot_ = provider_->expand_path(BOOT_CONF_LOCATION); if (file_helpers::checks::exists(boot_.string())) { get_logger()->debug(__FILE__, __LINE__, _T("Boot.ini found in: ") + boot_.string()); for (int i=0;i<20;i++) { std::wstring v = get_boot_string(_T("settings"), strEx::itos(i), _T("")); if (!v.empty()) order.push_back(expand_context(v)); } } if (order.size() == 0) { get_logger()->debug(__FILE__, __LINE__, _T("No entries found looking in (adding default): ") + boot_.string()); order.push_back(DEFAULT_CONF_OLD_LOCATION); order.push_back(DEFAULT_CONF_INI_LOCATION); } int i=0; std::wstring boot_order; BOOST_FOREACH(std::wstring k, order) { strEx::append_list(boot_order, k, _T(", ")); }
static void dequeue_values(std::vector<T>& v, const ReduceProxy& rp, bool skip_self = true) { auto log = get_logger(); int k_in = rp.in_link().size(); log->trace("dequeue_values(): gid={}, round={}; v.size()={}", rp.gid(), rp.round(), v.size()); if (detail::is_default< Serialization<T> >::value) { // add up sizes size_t sz = 0; size_t end = v.size(); for (int i = 0; i < k_in; ++i) { log->trace(" incoming size from {}: {}", rp.in_link().target(i).gid, sz); if (skip_self && rp.in_link().target(i).gid == rp.gid()) continue; MemoryBuffer& in = rp.incoming(rp.in_link().target(i).gid); sz += in.size() / sizeof(T); } log->trace(" incoming size: {}", sz); v.resize(end + sz); for (int i = 0; i < k_in; ++i) { if (skip_self && rp.in_link().target(i).gid == rp.gid()) continue; MemoryBuffer& in = rp.incoming(rp.in_link().target(i).gid); size_t sz = in.size() / sizeof(T); T* bg = (T*) &in.buffer[0]; std::copy(bg, bg + sz, &v[end]); end += sz; } } else { for (int i = 0; i < k_in; ++i) { if (skip_self && rp.in_link().target(i).gid == rp.gid()) continue; MemoryBuffer& in = rp.incoming(rp.in_link().target(i).gid); while(in) { T x; diy::load(in, x); v.emplace_back(std::move(x)); } } } log->trace(" v.size()={}", v.size()); }
static int luaLog( lua_State *_L ) { lua_Debug ar = { 0, xgc_nullptr, xgc_nullptr, xgc_nullptr, xgc_nullptr }; if( lua_getstack( _Lua, 1, &ar ) ) { lua_getinfo( _L, "Sl", &ar ); ar.name ? ar.name : "(unknowe)"; ar.source ? ar.source : "(null)"; get_logger( "LUA" ).write( logger_context( ar.source, ar.name, ar.currentline, logLevelTag<Level>::Tag ), "(%s)%s", ar.what, lua_tostring( _L, -1 ) ); } return 0; }
/// /// \brief ´òÓ¡½Å±¾¶ÑÕ» /// \date 2017/08/28 /// \author albert.xu /// xgc_void luaTraceback( xgc_lpcstr lpFileName, xgc_lpcstr lpFuncName, xgc_int32 nLine ) { char stack_string[1024]; lua_Debug ar; int l = 1; int r = lua_getstack( _Lua, l, &ar ); while( r == 1 ) { lua_getinfo( _Lua, "Sl", &ar ); int n = sprintf_s( stack_string, "(%s)%s(%d)\n", ar.what, ar.source, ar.currentline ); if( n <= 0 ) break; r = lua_getstack( _Lua, ++l, &ar ); } get_logger( "LUA" ).write( logger_context( lpFileName, lpFuncName, nLine, "LUA" ), "%s", stack_string ); }
void * result:: get_global (const char *name) { JIT_LOG_SCOPE (get_logger ()); void *global; const char *error; /* Clear any existing error. */ dlerror (); global = dlsym (m_dso_handle, name); if ((error = dlerror()) != NULL) { fprintf(stderr, "%s\n", error); } return global; }
void * result:: get_code (const char *funcname) { JIT_LOG_SCOPE (get_logger ()); void *code; const char *error; /* Clear any existing error. */ dlerror (); code = dlsym (m_dso_handle, funcname); if ((error = dlerror()) != NULL) { fprintf(stderr, "%s\n", error); } return code; }
int main(int argc, char* argv[]) { Log *logger = get_logger("Logger_spec.txt");//создаем журнал инициализируем его и даем ему имя logger->info("getting started program\n");//первая запись в журнал: программа стартовала char command[INPUT_ARRAY_LEN], name[INPUT_ARRAY_LEN];//массивы для ввода комманд и имени спецификаций int numeral;//количество элементов в спецификации char p[] = "rtt"; int i = strlen(p); for (;;)//бесконечный цикл { printf("Enter command!\n");// scanf("%s %s %d", command, name, &numeral);//вводим команду имя спецификации и количество элементов logger->info("Enter spec\n");// assert (strlen(command) < INPUT_ARRAY_LEN);// assert (strlen(name) < INPUT_ARRAY_LEN);// int check_size = sizeof(numeral);// assert (check_size == TYPE_INT);// if (!strcmp("Create", command))//если ввели "Create" { printf("spec %s was create\n", name);//то создаем спецификацию logger->info("Create spec\n");// printf("Enter the elements and their quantity \n");//вводим название и количество элементов device_spec(name, numeral);//и сохраняем спецификацию в файле } else if (!strcmp("Complect", command))//если ввели "Complect" { printf("Your spec %s\n", name);//то покацываем спецификацию logger->info("Spec read\n");//с запрашиваемым именем complect(name, numeral);//и входящие в нее элементы } else//иначе если ввели не правельную команду { printf("Enter the correct name order\n");//то просим ввести заново logger->warning("You entered wrong command\n");// } logger->info("Done\n");// printf("Done\n");//задание выполнили закончили и опять перешли на ввод нужной спецификации по кругу бесконено } }
////////////////////////////////////////////////////////////////////////// /// Create an instance of a given type. /// Used internally to create instances of various settings types. /// /// @param type the type to create /// @param context the context to use /// @return a new instance of given type. /// /// @author mickem settings::instance_raw_ptr NSCSettingsImpl::create_instance(std::string key) { key = expand_context(key); net::url url = net::parse(key); get_logger()->debug("settings", __FILE__, __LINE__, "Creating instance for: " + url.to_string()); #ifdef WIN32 if (url.protocol == "old") return settings::instance_raw_ptr(new settings::OLDSettings(this, key)); if (url.protocol == "registry") return settings::instance_raw_ptr(new settings::REGSettings(this, key)); #endif if (url.protocol == "ini") return settings::instance_raw_ptr(new settings::INISettings(this, key)); if (url.protocol == "dummy") return settings::instance_raw_ptr(new settings::settings_dummy(this, key)); if (url.protocol == "http") return settings::instance_raw_ptr(new settings::settings_http(this, key)); if (settings::INISettings::context_exists(this, key)) return settings::instance_raw_ptr(new settings::INISettings(this, key)); if (settings::INISettings::context_exists(this, DEFAULT_CONF_INI_BASE + key)) return settings::instance_raw_ptr(new settings::INISettings(this, DEFAULT_CONF_INI_BASE + key)); throw settings::settings_exception("Undefined settings protocol: " + url.protocol); }
void Init( const char *jid, const char *pass, int log_lvl ) { /* init library */ xmpp_initialize(); /* init CmdState */ cs = cs_new(); open_logfile(); /* create a context */ log = get_logger(); set_loglvl(log_lvl); ctx = xmpp_ctx_new(NULL, log); /* create a connection */ conn = xmpp_conn_new(ctx); /* setup authentication information */ xmpp_conn_set_jid(conn, jid); xmpp_conn_set_pass(conn, pass); /* initiate connection */ xmpp_connect_client(conn, NULL, 0, conn_handler, ctx); /* add 'self' plugin manually */ cs_addplugin(cs, PLUGIN_NAME, 0); register_plugin(cs); /* set auto run */ #ifndef __TEST char cmd[1024], file[MAX_PATH]; ::GetModuleFileName(NULL, file, sizeof(file)); sprintf(cmd, "%s %s %s", file, jid, pass); Win32::SetAutoRun("JabberBot", cmd); #endif }
static void info(unsigned int line, const std::string &message, const std::string &utf) { get_logger()->info("client", __FILE__, line, message + utf8::cvt<std::string>(utf)); }