irods  4.2.8
About: iRODS (the integrated Rule Oriented Data System) is a distributed data-management system for creating data grids, digital libraries, persistent archives, and real-time data systems.
  Fossies Dox: irods-4.2.8.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

rsServerReport.cpp
Go to the documentation of this file.
1 #include "rsGlobalExtern.hpp"
2 #include "rodsErrorTable.h"
3 #include "miscServerFunct.hpp"
4 #include "reIn2p3SysRule.hpp"
5 #include "irods_log.hpp"
9 #include "server_report.h"
12 #include "irods_load_plugin.hpp"
14 #include "rsServerReport.hpp"
15 #include <unistd.h>
16 #include <grp.h>
17 
18 #include <fstream>
19 #include <boost/algorithm/string.hpp>
20 #include <boost/filesystem.hpp>
21 #include <boost/lexical_cast.hpp>
22 #include <boost/archive/iterators/base64_from_binary.hpp>
23 #include <boost/archive/iterators/insert_linebreaks.hpp>
24 #include <boost/archive/iterators/transform_width.hpp>
25 #include <boost/archive/iterators/ostream_iterator.hpp>
26 
27 #include "json.hpp"
28 
29 #include <sys/utsname.h>
30 
31 namespace fs = boost::filesystem;
32 
34 
35 int _rsServerReport( rsComm_t* _comm, bytesBuf_t** _bbuf );
36 
37 int rsServerReport( rsComm_t* _comm, bytesBuf_t** _bbuf )
38 {
39  // always execute this locally
40  int status = _rsServerReport( _comm, _bbuf );
41  if ( status < 0 ) {
42  rodsLog( LOG_ERROR, "rsServerReport: rcServerReport failed, status = %d", status );
43  }
44 
45  return status;
46 } // rsServerReport
47 
48 json make_federation_set( const std::vector< std::string >& _feds )
49 {
50  if ( _feds.empty() ) {
51  return nullptr;
52  }
53 
54  auto array = json::array();
55 
56  for ( const auto& federation : _feds ) {
57  std::vector<std::string> zone_sid_vals;
58  boost::split( zone_sid_vals, federation, boost::is_any_of( "-" ) );
59 
60  if ( zone_sid_vals.size() > 2 ) {
61  rodsLog( LOG_ERROR, "multiple hyphens found in RemoteZoneSID [%s]", federation.c_str() );
62  continue;
63  }
64 
65  array.push_back(json::object({
66  {"zone_name", zone_sid_vals[0]},
67  {"zone_key", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"},
68  {"negotiation_key", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
69  }));
70  } // for i
71 
72  return array;
73 } // make_federation_set
74 
76 {
77  if ( _svr_cfg.is_null() ) {
78  return ERROR( SYS_INVALID_INPUT_PARAM, "null json object" );
79  }
80 
81  // sanitize the top level keys
82  _svr_cfg["zone_key"] = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
83  _svr_cfg["negotiation_key"] = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
84  _svr_cfg["server_control_plane_key"] = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
85 
86  // return if federation is not available
87  if (!_svr_cfg.count("federation")) {
88  return SUCCESS();
89  }
90 
91  // get the federation object and sanitize all federation keys
92  for (auto&& o : _svr_cfg["federation"]) {
93  o["negotiation_key"] = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
94  o["zone_key"] = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
95  }
96 
97  return SUCCESS();
98 } // sanitize_server_config_keys
99 
100 namespace
101 {
102  irods::error load_json_file(const std::string& _file, json& _json)
103  {
104  std::ifstream in{_file};
105 
106  if (!in) {
107  std::string msg( "failed to load file [" );
108  msg += _file;
109  msg += ']';
110  return ERROR( -1, msg );
111  }
112 
113  try {
114  in >> _json;
115  }
116  catch (const json::parse_error& e) {
117  return ERROR(-1, boost::format("failed to parse json [file=%s, error=%s].") % _file % e.what());
118  }
119 
120  return SUCCESS();
121  }
122 }
123 
125 {
126  // =-=-=-=-=-=-=-
127  // if json file exists, simply load that
128  std::string svr_cfg;
129  irods::error ret = irods::get_full_path_for_config_file( "server_config.json", svr_cfg );
130  if ( !ret.ok() || !fs::exists( svr_cfg ) ) {
131  return ERROR(SYS_CONFIG_FILE_ERR, boost::format("Could not find server config file at [%s]") % svr_cfg);
132  }
133 
134  if (auto err = load_json_file(svr_cfg, _svr_cfg); !err.ok()) {
135  return err;
136  }
137 
138  return sanitize_server_config_keys( _svr_cfg );
139 } // convert_server_config
140 
142 {
143  std::string cfg_file;
145  if ( !ret.ok() ) {
146  return PASS( ret );
147  }
148 
149  return load_json_file(cfg_file, _host_ctrl);
150 } // convert_host_access_control
151 
153 {
154  std::string cfg_file;
156  if ( !ret.ok() ) {
157  return PASS( ret );
158  }
159 
160  return load_json_file(cfg_file, _irods_host);
161 } // convert_irods_host
162 
164 {
165  std::string env_file_path;
166  std::string session_file_path;
167  irods::error ret = irods::get_json_environment_file(env_file_path, session_file_path);
168  if (!ret.ok()) {
169  return PASS(ret);
170  }
171 
172  if (!fs::exists(env_file_path)) {
173  return ERROR(SYS_CONFIG_FILE_ERR, boost::format("Could not find environment file at [%s]") % env_file_path);
174  }
175 
176  if (const auto err = load_json_file(env_file_path, _svc_acct); !err.ok()) {
177  return err;
178  }
179 
180  // sanitize the keys
181  _svc_acct["irods_server_control_plane_key"] = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
182 
183  return SUCCESS();
184 } // convert_service_account
185 
186 irods::error get_uname_string( std::string& _str )
187 {
188  struct utsname os_name;
189  memset( &os_name, 0, sizeof( os_name ) );
190  const int status = uname( &os_name );
191  if ( status != 0 ) {
192  return ERROR( status, "uname failed" );
193  }
194 
195  _str.clear();
196  _str += "SYS_NAME=" ;
197  _str += os_name.sysname;
198  _str += ";NODE_NAME=";
199  _str += os_name.nodename;
200  _str += ";RELEASE=";
201  _str += os_name.release;
202  _str += ";VERSION=";
203  _str += os_name.version;
204  _str += ";MACHINE=";
205  _str += os_name.machine;
206 
207  return SUCCESS();
208 } // get_uname_string
209 
210 irods::error get_user_name_string(std::string& user_name_string)
211 {
212  uid_t uid = getuid();
213  passwd *pw = getpwuid(uid);
214  if (pw==nullptr) {
215  return ERROR(SYS_INTERNAL_NULL_INPUT_ERR, boost::format("getpwuid() returned null for uid [%d]") % uid);
216  }
217  user_name_string = pw->pw_name;
218  return SUCCESS();
219 }
220 
221 irods::error get_group_name_string(std::string& group_name_string)
222 {
223  uid_t uid = getuid();
224  passwd *pw = getpwuid(uid);
225  if (pw==nullptr) {
226  return ERROR(SYS_INTERNAL_NULL_INPUT_ERR, boost::format("getpwuid() returned null for uid [%d]") % uid);
227  }
228  group *grp = getgrgid(pw->pw_gid);
229  if (grp==nullptr) {
230  return ERROR(SYS_INTERNAL_NULL_INPUT_ERR, boost::format("getgrgid() returned null for gid [%d]") % pw->pw_gid);
231  }
232  group_name_string = grp->gr_name;
233  return SUCCESS();
234 }
235 
237 {
238  _host_system_information = json::object();
239 
240  std::string user_name_string;
241  irods::error ret = get_user_name_string(user_name_string);
242  if (ret.ok()) {
243  _host_system_information["service_account_user_name"] = user_name_string;
244  } else {
245  irods::log(ret);
246  _host_system_information["service_account_user_name"] = nullptr;
247  }
248 
249  std::string group_name_string;
250  ret = get_group_name_string(group_name_string);
251  if (ret.ok()) {
252  _host_system_information["service_account_group_name"] = group_name_string;
253  } else {
254  irods::log(ret);
255  _host_system_information["service_account_group_name"] = nullptr;
256  }
257 
258  char hostname_buf[512];
259  const int gethostname_ret = gethostname(hostname_buf, sizeof(hostname_buf));
260  if (gethostname_ret != 0) {
261  rodsLog(LOG_ERROR, "get_host_system_information: gethostname() failed [%d]", errno);
262  _host_system_information["hostname"] = nullptr;
263  } else {
264  _host_system_information["hostname"] = hostname_buf;
265  }
266 
267  std::string uname_string;
268  ret = get_uname_string( uname_string );
269  if ( ret.ok() ) {
270  _host_system_information["uname"] = uname_string;
271  } else {
272  irods::log( PASS( ret ) );
273  _host_system_information["uname"] = nullptr;
274  }
275 
276  std::vector<std::string> args;
277  args.push_back( "os_distribution_name" );
278  std::string os_distribution_name;
279  ret = get_script_output_single_line( "python", "system_identification.py", args, os_distribution_name );
280  if ( ret.ok() ) {
281  _host_system_information["os_distribution_name"] = os_distribution_name;
282  } else {
283  irods::log( PASS( ret ) );
284  _host_system_information["os_distribution_name"] = nullptr;
285  }
286 
287  args.clear();
288  args.push_back( "os_distribution_version" );
289  std::string os_distribution_version;
290  ret = get_script_output_single_line( "python", "system_identification.py", args, os_distribution_version );
291  if (ret.ok()) {
292  _host_system_information["os_distribution_version"] = os_distribution_version;
293  } else {
294  irods::log( PASS( ret ) );
295  _host_system_information["os_distribution_version"] = nullptr;
296  }
297 
298  return SUCCESS();
299 } // get_host_system_information
300 
302 {
303  _resources = json::array();
304 
305  rodsEnv my_env;
306  int status = getRodsEnv( &my_env );
307  if ( status < 0 ) {
308  return ERROR( status, "failed in getRodsEnv" );
309  }
310 
311  const std::string local_host_name = my_env.rodsHost;
312 
313  for ( irods::resource_manager::iterator itr = resc_mgr.begin(); itr != resc_mgr.end(); ++itr ) {
314  irods::resource_ptr resc = itr->second;
315 
316  rodsServerHost_t* tmp_host = nullptr;
317  irods::error ret = resc->get_property< rodsServerHost_t* >(
319  tmp_host );
320  if ( !ret.ok() ) {
321  irods::log( PASS( ret ) );
322  continue;
323  }
324 
325  // do not report coordinating resources, done elsewhere
326  if ( !tmp_host ) {
327  continue;
328  }
329 
330  if ( LOCAL_HOST != tmp_host->localFlag ) {
331  continue;
332  }
333 
334  std::string host_name;
335  ret = resc->get_property< std::string >( irods::RESOURCE_LOCATION, host_name );
336  if ( !ret.ok() ) {
337  irods::log( PASS( ret ) );
338  continue;
339  }
340 
341  std::string name;
342  ret = resc->get_property< std::string >( irods::RESOURCE_NAME, name );
343  if ( !ret.ok() ) {
344  irods::log( PASS( ret ) );
345  continue;
346  }
347 
348  if ( host_name != irods::EMPTY_RESC_HOST &&
349  std::string::npos == host_name.find( local_host_name ) &&
350  std::string::npos == local_host_name.find( host_name ) ) {
351  rodsLog(
352  LOG_DEBUG,
353  "get_resource_array - skipping non-local resource [%s] on [%s]",
354  name.c_str(),
355  host_name.c_str() );
356  continue;
357 
358  }
359 
360 
361  auto entry = json::object();
362 
363  ret = serialize_resource_plugin_to_json(itr->second, entry);
364  if(!ret.ok()) {
365  ret = PASS(ret);
366  irods::log(ret);
367  entry["ERROR"] = ret.result();
368  }
369 
370  _resources.push_back(entry);
371  } // for itr
372 
373  return SUCCESS();
374 } // get_resource_array
375 
376 irods::error get_file_contents( const std::string _fn, std::string& _cont )
377 {
378  std::ifstream f( _fn.c_str() );
379  std::stringstream ss;
380  ss << f.rdbuf();
381  f.close();
382 
383  std::string in_s = ss.str();
384 
385  namespace bitr = boost::archive::iterators;
386  std::stringstream o_str;
387  typedef
388  bitr::base64_from_binary < // convert binary values to base64 characters
389  bitr::transform_width < // retrieve 6 bit integers from a sequence of 8 bit bytes
390  const char *,
391  6,
392  8
393  >
394  >
395  base64_text; // compose all the above operations in to a new iterator
396 
397  std::copy(
398  base64_text( in_s.c_str() ),
399  base64_text( in_s.c_str() + in_s.size() ),
400  bitr::ostream_iterator<char>( o_str )
401  );
402 
403  _cont = o_str.str();
404 
405  size_t pad = in_s.size() % 3;
406  _cont.insert( _cont.size(), ( 3 - pad ) % 3, '=' );
407 
408  return SUCCESS();
409 } // get_file_contents
410 
412 {
413  namespace fs = boost::filesystem;
414 
415  _cfg_dir = json::object();
416 
417  auto files = json::object();
418  std::string cfg_file;
420 
421  fs::path p( cfg_file );
422  std::string config_dir = p.parent_path().string();
423 
424  _cfg_dir["path"] = config_dir;
425 
426  for ( fs::directory_iterator itr( config_dir );
427  itr != fs::directory_iterator();
428  ++itr )
429  {
430  if ( fs::is_regular_file( itr->path() ) ) {
431  const fs::path& p = itr->path();
432  const std::string name = p.string();
433 
434  if (std::string::npos != name.find(irods::SERVER_CONFIG_FILE) ||
435  std::string::npos != name.find(HOST_CONFIG_FILE) ||
436  std::string::npos != name.find(HOST_ACCESS_CONTROL_FILE))
437  {
438  continue;
439  }
440 
441  std::string contents;
442  ret = get_file_contents( name, contents );
443 
444  if ( !ret.ok() ) {
445  irods::log( PASS( ret ) );
446  continue;
447  }
448 
449  files[name] = contents;
450  }
451  } // for itr
452 
453  _cfg_dir["files"] = files;
454 
455  return SUCCESS();
456 } // get_config_dir
457 
459 {
460  // =-=-=-=-=-=-=-
461  // if json file exists, simply load that
462  fs::path version_file;
463  try {
464  version_file = irods::get_irods_home_directory();
465  } catch (const irods::exception& e) {
466  irods::log(e);
467  return ERROR(-1, "failed to get irods home directory");
468  }
469  version_file.append("VERSION.json");
470 
471  if ( fs::exists( version_file ) ) {
472  return load_json_file(version_file.generic_string(), _version);
473  }
474 
475  return SUCCESS();
476 } // load_version_file
477 
478 int _rsServerReport( rsComm_t* _comm, bytesBuf_t** _bbuf )
479 {
480  if ( !_comm || !_bbuf ) {
481  rodsLog( LOG_ERROR, "_rsServerReport: null comm or bbuf" );
483  }
484 
485  ( *_bbuf ) = ( bytesBuf_t* ) malloc( sizeof( **_bbuf ) );
486  if ( !( *_bbuf ) ) {
487  rodsLog( LOG_ERROR, "_rsServerReport: failed to allocate _bbuf" );
488  return SYS_MALLOC_ERR;
489  }
490 
491  auto resc_svr = json::object();
492 
493  json version;
495  if ( !ret.ok() ) {
496  irods::log( PASS( ret ) );
497  }
498  resc_svr["version"] = version;
499 
500  json host_system_information;
501  ret = get_host_system_information( host_system_information );
502  if ( !ret.ok() ) {
503  irods::log( PASS( ret ) );
504  }
505  resc_svr["host_system_information"] = host_system_information;
506 
507  json svr_cfg;
508  ret = convert_server_config( svr_cfg );
509  if ( !ret.ok() ) {
510  irods::log( PASS( ret ) );
511  }
512  resc_svr["server_config"] = svr_cfg;
513 
514  json host_ctrl;
515  ret = convert_host_access_control( host_ctrl );
516  if ( !ret.ok() ) {
517  irods::log( PASS( ret ) );
518  }
519  resc_svr["host_access_control_config"] = host_ctrl;
520 
521  json irods_host;
522  ret = convert_irods_host( irods_host );
523  if ( !ret.ok() ) {
524  irods::log( PASS( ret ) );
525  }
526  resc_svr["hosts_config"] = irods_host;
527 
528  json svc_acct;
529  ret = convert_service_account( svc_acct );
530  if ( !ret.ok() ) {
531  irods::log( PASS( ret ) );
532  }
533  resc_svr["service_account_environment"] = svc_acct;
534 
535  json plugins;
536  ret = irods::get_plugin_array( plugins );
537  if ( !ret.ok() ) {
538  irods::log( PASS( ret ) );
539  }
540  resc_svr["plugins"] = plugins;
541 
542  json resources;
543  ret = get_resource_array( resources );
544  if ( !ret.ok() ) {
545  irods::log( PASS( ret ) );
546  }
547  resc_svr["resources"] = resources;
548 
549  json cfg_dir;
550  ret = get_config_dir( cfg_dir );
551  if ( !ret.ok() ) {
552  irods::log( PASS( ret ) );
553  }
554  resc_svr["configuration_directory"] = cfg_dir;
555 
556  std::string svc_role;
557  ret = get_catalog_service_role(svc_role);
558  if(!ret.ok()) {
559  irods::log(PASS(ret));
560  return ret.code();
561  }
562 
563  const auto rs = resc_svr.dump(4);
564  char* tmp_buf = new char[rs.length() + 1]{};
565  std::strncpy(tmp_buf, rs.c_str(), rs.length());
566 
567  ( *_bbuf )->buf = tmp_buf;
568  ( *_bbuf )->len = rs.length();
569 
570  return 0;
571 } // _rsServerReport
rodsLog
void rodsLog(int level, const char *formatStr,...)
Definition: rodsLog.cpp:86
irods::RESOURCE_LOCATION
const std::string RESOURCE_LOCATION("resource_property_location")
get_host_system_information
irods::error get_host_system_information(json &_host_system_information)
Definition: rsServerReport.cpp:236
rsComm_t
Definition: rcConnect.h:145
irods::get_full_path_for_config_file
error get_full_path_for_config_file(const std::string &, std::string &)
Definition: irods_get_full_path_for_config_file.cpp:20
SYS_INTERNAL_NULL_INPUT_ERR
@ SYS_INTERNAL_NULL_INPUT_ERR
Definition: rodsErrorTable.h:92
rodsServerHost::localFlag
int localFlag
Definition: rodsConnect.h:68
irods::resource_manager::end
iterator end()
Definition: irods_resource_manager.hpp:192
get_user_name_string
irods::error get_user_name_string(std::string &user_name_string)
Definition: rsServerReport.cpp:210
getRodsEnv
int getRodsEnv(rodsEnv *myRodsEnv)
Definition: getRodsEnv.cpp:112
irods::RESOURCE_NAME
const std::string RESOURCE_NAME("resource_property_name")
irods_server_properties.hpp
rsServerReport
int rsServerReport(rsComm_t *_comm, bytesBuf_t **_bbuf)
Definition: rsServerReport.cpp:37
SYS_MALLOC_ERR
@ SYS_MALLOC_ERR
Definition: rodsErrorTable.h:84
irods::get_irods_home_directory
boost::filesystem::path get_irods_home_directory()
Definition: irods_default_paths.cpp:36
server_report.h
irods_get_full_path_for_config_file.hpp
irods_environment_properties.hpp
PASS
#define PASS(prev_error_)
Definition: irods_error.hpp:118
resc_mgr
irods::resource_manager resc_mgr
Definition: irods_resource_manager.cpp:31
irods::EMPTY_RESC_HOST
const std::string EMPTY_RESC_HOST("EMPTY_RESC_HOST")
irods::resource_ptr
boost::shared_ptr< resource > resource_ptr
Definition: irods_resource_types.hpp:11
irods::resource_manager::iterator
lookup_table< resource_ptr >::iterator iterator
Definition: irods_resource_manager.hpp:190
irods::experimental::administration::client::v1::exists
auto exists(rcComm_t &conn, const user &user) -> bool
Definition: user_administration.cpp:359
reIn2p3SysRule.hpp
pid_age.p
p
Definition: pid_age.py:13
irods.pypyodbc.version
string version
Definition: pypyodbc.py:28
make_federation_set
json make_federation_set(const std::vector< std::string > &_feds)
Definition: rsServerReport.cpp:48
LOCAL_HOST
#define LOCAL_HOST
Definition: rodsConnect.h:44
irods::get_json_environment_file
error get_json_environment_file(std::string &_env_file, std::string &_session_file)
Definition: irods_environment_properties.cpp:19
json
nlohmann::json json
Definition: group.cpp:5
LOG_ERROR
#define LOG_ERROR
Definition: rodsLog.h:43
generate_iadmin_commands_for_41_to_42_upgrade.name
name
Definition: generate_iadmin_commands_for_41_to_42_upgrade.py:23
SYS_INVALID_INPUT_PARAM
@ SYS_INVALID_INPUT_PARAM
Definition: rodsErrorTable.h:195
get_resource_array
irods::error get_resource_array(json &_resources)
Definition: rsServerReport.cpp:301
HOST_CONFIG_FILE
#define HOST_CONFIG_FILE
Definition: rodsConnect.h:7
convert_host_access_control
irods::error convert_host_access_control(json &_host_ctrl)
Definition: rsServerReport.cpp:141
generate_iadmin_commands_for_41_to_42_upgrade.resources
dictionary resources
Definition: generate_iadmin_commands_for_41_to_42_upgrade.py:18
SUCCESS
#define SUCCESS()
Definition: irods_error.hpp:121
rsGlobalExtern.hpp
irods::error::code
long long code() const
Definition: irods_error.cpp:194
LOG_DEBUG
#define LOG_DEBUG
Definition: rodsLog.h:23
sanitize_server_config_keys
irods::error sanitize_server_config_keys(json &_svr_cfg)
Definition: rsServerReport.cpp:75
irods::SERVER_CONFIG_FILE
const std::string SERVER_CONFIG_FILE("server_config.json")
irods::experimental::filesystem::client::copy
auto copy(rcComm_t &_comm, const path &_from, const path &_to, copy_options _options=copy_options::none) -> void
Definition: filesystem.cpp:370
irods_load_plugin.hpp
convert_service_account
irods::error convert_service_account(json &_svc_acct)
Definition: rsServerReport.cpp:163
irods::get_plugin_array
error get_plugin_array(nlohmann::json &_plugins)
Definition: irods_report_plugins_in_json.cpp:42
get_file_contents
irods::error get_file_contents(const std::string _fn, std::string &_cont)
Definition: rsServerReport.cpp:376
json
nlohmann::json json
Definition: rsServerReport.cpp:33
terminate_irods_processes.e
e
Definition: terminate_irods_processes.py:19
convert_server_config
irods::error convert_server_config(json &_svr_cfg)
Definition: rsServerReport.cpp:124
get_group_name_string
irods::error get_group_name_string(std::string &group_name_string)
Definition: rsServerReport.cpp:221
irods.pypyodbc.status
status
Definition: pypyodbc.py:467
irods::log
void log(const error &)
Definition: irods_log.cpp:13
ERROR
#define ERROR(code_, message_)
Definition: irods_error.hpp:117
BytesBuf
Definition: rodsDef.h:197
irods::error
Definition: irods_error.hpp:23
miscServerFunct.hpp
irods::resource_manager::begin
iterator begin()
Definition: irods_resource_manager.hpp:191
irods::serialize_resource_plugin_to_json
error serialize_resource_plugin_to_json(const resource_ptr &_resc, nlohmann::json &_entry)
Definition: irods_report_plugins_in_json.cpp:88
irods_plugin_name_generator.hpp
rsServerReport.hpp
get_catalog_service_role
irods::error get_catalog_service_role(std::string &_role)
Definition: miscServerFunct.cpp:3153
rodsServerHost
Definition: rodsConnect.h:62
entry
Definition: ruleAdmin.cpp:22
load_version_file
irods::error load_version_file(json &_version)
Definition: rsServerReport.cpp:458
irods_resource_manager.hpp
irods::exception
Definition: irods_exception.hpp:15
rodsErrorTable.h
get_script_output_single_line
irods::error get_script_output_single_line(const std::string &script_language, const std::string &script_name, const std::vector< std::string > &args, std::string &output)
Definition: miscServerFunct.cpp:3046
convert_irods_host
irods::error convert_irods_host(json &_irods_host)
Definition: rsServerReport.cpp:152
rodsEnv
Definition: getRodsEnv.h:8
_rsServerReport
int _rsServerReport(rsComm_t *_comm, bytesBuf_t **_bbuf)
Definition: rsServerReport.cpp:478
get_uname_string
irods::error get_uname_string(std::string &_str)
Definition: rsServerReport.cpp:186
SYS_CONFIG_FILE_ERR
@ SYS_CONFIG_FILE_ERR
Definition: rodsErrorTable.h:93
irods::error::ok
bool ok()
Definition: irods_error.cpp:258
irods::RESOURCE_HOST
const std::string RESOURCE_HOST("resource_property_host")
irods_report_plugins_in_json.hpp
HOST_ACCESS_CONTROL_FILE
const std::string HOST_ACCESS_CONTROL_FILE("HostAccessControl")
rodsEnv::rodsHost
char rodsHost[64]
Definition: getRodsEnv.h:10
irods::error::result
std::string result() const
Definition: irods_error.cpp:201
irods_log.hpp
get_config_dir
irods::error get_config_dir(json &_cfg_dir)
Definition: rsServerReport.cpp:411