Changeset 7354aa1 in nscp

Timestamp:

01/09/12 22:34:25 (17 months ago)

Author:

Michael Medin <michael@…>

Branches:

master, 0.4.0, 0.4.1, 0.4.2

Children:

ba63b95

Parents:

a87ce04

Message:

• Fixed hostname issue in NSCAClient (hostname = auto now auto detects hostname
• Fixed some minor issues in NSCA and CLI api
• Added CLI based (exec) APIs to NSCA unit tests (now 697 test for NSCA)

Files:

• changelog (modified) (1 diff)
• include/client/command_line_parser.cpp (modified) (3 diffs)
• include/client/command_line_parser.hpp (modified) (1 diff)
• include/nscapi/functions.hpp (modified) (4 diffs)
• modules/NSCAClient/NSCAClient.cpp (modified) (4 diffs)
• modules/NSCAClient/NSCAClient.h (modified) (1 diff)
• scripts/python/test_nsca.py (modified) (4 diffs)

changelog

@@ -6 +6 @@
  * Fix RtlStringFromGUID problem on NT4
 
+2012-01-09 MickeM
+ * Fixed hostname issue in NSCAClient (hostname = auto now auto detects hostname
+ * Fixed some minor issues in NSCA and CLI api
+ * Added CLI based (exec) APIs to NSCA unit tests (now 697 test for NSCA)
 
 2012-01-08 MickeM

include/client/command_line_parser.cpp

@@ -25 +25 @@
   desc.add_options()
     ("command,c", po::wvalue<std::wstring>(&command_data->command), "The name of the command that the remote daemon should run")
+    ("alias,a", po::wvalue<std::wstring>(&command_data->command), "Same as command")
     ("message,m", po::wvalue<std::wstring>(&command_data->message), "Message")
-    ("result,r", po::value<unsigned int>(&command_data->result), "Result code")
+    ("result,r", po::wvalue<std::wstring>(&command_data->result), "Result code either a number or OK, WARN, CRIT, UNKNOWN")
     ;
 }
@@ -52 +53 @@
 }
 
+int parse_result(std::wstring key) {
+  if (key == _T("UNKNOWN") || key == _T("unknown"))
+    return NSCAPI::returnUNKNOWN;
+  if (key == _T("warn") || key == _T("WARN") || key == _T("WARNING") || key == _T("warning"))
+    return NSCAPI::returnWARN;
+  if (key == _T("crit") || key == _T("CRIT") || key == _T("CRITICAL") || key == _T("critical"))
+    return NSCAPI::returnWARN;
+  if (key == _T("OK") || key == _T("ok"))
+    return NSCAPI::returnUNKNOWN;
+  try {
+    return strEx::stoi(key);
+  } catch (...) {
+    return NSCAPI::returnUNKNOWN;
+  }
+}
 
 int client::command_line_parser::do_execute_command_as_exec(configuration &config, const std::wstring &command, std::list<std::wstring> &arguments, std::string &result) {
@@ -226 +242 @@
   modify_header(config, message.mutable_header(), config.data->recipient);
   message.set_channel("CLI");
-  nscapi::functions::append_simple_submit_request_payload(message.add_payload(), config.data->command, config.data->result, config.data->message);
+  nscapi::functions::append_simple_submit_request_payload(message.add_payload(), config.data->command, parse_result(config.data->result), config.data->message);
 
   return config.handler->submit(config.data, message.mutable_header(), message.SerializeAsString(), result);

include/client/command_line_parser.hpp

@@ -32 +32 @@
     std::wstring command_line;
     std::wstring message;
-    unsigned int result;
+    std::wstring result;
     std::vector<std::wstring> arguments;
 

include/nscapi/functions.hpp

@@ -347 +347 @@
       exec_response_message.ParseFromString(data);
       Plugin::QueryResponseMessage query_response_message;
-      query_response_message.mutable_header()->CopyFrom(exec_response_message);
+      query_response_message.mutable_header()->CopyFrom(exec_response_message.header());
       for (int i=0;i<exec_response_message.payload_size();++i) {
         Plugin::ExecuteResponseMessage::Response p = exec_response_message.payload(i);
@@ -358 +358 @@
       submit_response_message.ParseFromString(data);
       Plugin::QueryResponseMessage query_response_message;
-      query_response_message.mutable_header()->CopyFrom(submit_response_message);
+      query_response_message.mutable_header()->CopyFrom(submit_response_message.header());
       for (int i=0;i<submit_response_message.payload_size();++i) {
         Plugin::SubmitResponseMessage::Response p = submit_response_message.payload(i);
@@ -370 +370 @@
       submit_response_message.ParseFromString(data);
       Plugin::ExecuteResponseMessage exec_response_message;
-      exec_response_message.mutable_header()->CopyFrom(submit_response_message);
+      exec_response_message.mutable_header()->CopyFrom(submit_response_message.header());
       for (int i=0;i<submit_response_message.payload_size();++i) {
         Plugin::SubmitResponseMessage::Response p = submit_response_message.payload(i);
@@ -381 +381 @@
       query_response_message.ParseFromString(data);
       Plugin::ExecuteResponseMessage exec_response_message;
-      exec_response_message.mutable_header()->CopyFrom(query_response_message);
+      exec_response_message.mutable_header()->CopyFrom(query_response_message.header());
       for (int i=0;i<query_response_message.payload_size();++i) {
         Plugin::QueryResponseMessage::Response p = query_response_message.payload(i);

modules/NSCAClient/NSCAClient.cpp

@@ -80 +80 @@
 
     settings.alias().add_key_to_settings()
-      (_T("hostname"), sh::string_key(&hostname_),
+      (_T("hostname"), sh::string_key(&hostname_, "auto"),
       _T("HOSTNAME"), _T("The host name of this host if set to blank (default) the windows name of the computer will be used."))
 
@@ -122 +122 @@
 
     get_core()->registerSubmissionListener(get_id(), channel_);
+
+    if (hostname_ == "auto") {
+      hostname_ = boost::asio::ip::host_name();
+
+    }
 
     if (!targets.has_target(_T("default"))) {
@@ -224 +229 @@
 NSCAPI::nagiosReturn NSCAAgent::handleRAWCommand(const wchar_t* char_command, const std::string &request, std::string &result) {
   nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_query_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(data.command, _T("syslog"));
+  std::wstring cmd = client::command_line_parser::parse_command(data.command, _T("nsca"));
   client::configuration config;
   setup(config);
@@ -234 +239 @@
 NSCAPI::nagiosReturn NSCAAgent::commandRAWLineExec(const wchar_t* char_command, const std::string &request, std::string &result) {
   nscapi::functions::decoded_simple_command_data data = nscapi::functions::parse_simple_exec_request(char_command, request);
-  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("syslog"));
+  std::wstring cmd = client::command_line_parser::parse_command(char_command, _T("nsca"));
   if (!client::command_line_parser::is_command(cmd))
     return NSCAPI::returnIgnored;

modules/NSCAClient/NSCAClient.h

@@ -68 +68 @@
       host = url.host;
       port = url.get_port();
-      sender_hostname = sender.get_string_data("host");
+      sender_hostname = sender.host;
+      if (sender.has_data("host"))
+        sender_hostname = sender.get_string_data("host");
     }
     unsigned int get_encryption() {

scripts/python/test_nsca.py

@@ -121 +121 @@
     None
     
-  def submit_payload(self, encryption, source, status, msg, perf):
+  def wait_and_validate(self, uuid, result, msg, perf, tag):
+    found = False
+    for i in range(0,10):
+      if self.has_response(uuid):
+        rmsg = self.get_response(uuid)
+        result.add_message(rmsg.got_response, 'Testing to recieve message using %s'%tag)
+        result.add_message(rmsg.got_simple_response, 'Testing to recieve simple message using %s'%tag)
+        #result.assert_equals(rmsg.last_source, source, 'Verify that source is sent through')
+        result.assert_equals(rmsg.command, uuid, 'Verify that command is sent through using %s'%tag)
+        result.assert_contains(rmsg.message, msg, 'Verify that message is sent through using %s'%tag)
+        result.assert_equals(rmsg.perfdata, perf, 'Verify that performance data is sent through using %s'%tag)
+        self.del_response(uuid)
+        return True
+      else:
+        log('Waiting for %s (%d/10)'%(uuid, i+1))
+        sleep(1)
+    result.add_message(False, 'Failed to recieve message %s using %s'%(uuid, tag))
+    return False
+  
+    
+  def submit_payload(self, encryption, source, status, msg, perf, tag, retry=True):
     message = plugin_pb2.SubmitRequestMessage()
     
@@ -144 +164 @@
     payload.source = source
     (result_code, err) = core.submit('nsca_test_outbox', message.SerializeToString())
-    result = TestResult()
-    
-    found = False
-    for i in range(0,10):
-      if self.has_response(uid):
-        rmsg = self.get_response(uid)
-        result.add_message(rmsg.got_response, 'Testing to recieve message using %s'%encryption)
-        result.add_message(rmsg.got_simple_response, 'Testing to recieve simple message using %s'%encryption)
-        result.add_message(len(err) == 0, 'Testing to send message using %s'%encryption, err)
-        #result.assert_equals(rmsg.last_source, source, 'Verify that source is sent through')
-        result.assert_equals(rmsg.command, uid, 'Verify that command is sent through')
-        result.assert_contains(rmsg.message, msg, 'Verify that message is sent through')
-        result.assert_equals(rmsg.perfdata, perf, 'Verify that performance data is sent through')
-        self.del_response(uid)
-        found = True
-        break
-      else:
-        log('Waiting for %s'%uid)
-        sleep(1)
-    if not found:
-      return None
+
+    result = TestResult()
+    result.add_message(len(err) == 0, 'Testing to send message using %s/sbp'%tag, err)
+    found = self.wait_and_validate(uid, result, msg, perf, '%s/spb'%tag)
+    if retry and not found:
+      return self.submit_payload(encryption, source, status, msg, perf, tag, False)
+    return result
+    
+  def submit_via_exec(self, encryption, source, status, msg, perf, tag, retry=True):
+    uid = str(uuid.uuid4())
+  
+    args = [
+      #'--exec', 'submit', 
+      '--alias', uid, 
+      '--result', '%d'%status, 
+      '--message', '%s - %s'%(uid, msg), 
+      '--encryption', encryption,
+      '--password', 'pwd-%s'%encryption,
+      '--host', '127.0.0.1:15667'
+      ]
+    (result_code, result_message) = core.simple_exec('any', 'nsca_submit', args)
+    result = TestResult()
+    
+    result.add_message(result_code == 0, 'Testing to send message using %s/exec:1'%tag)
+    result.add_message(len(result_message) == 1, 'Testing to send message using %s/exec:2'%tag, len(result_message))
+    result.add_message(len(result_message[0]) == 0, 'Testing to send message using %s/exec:3'%tag, result_message[0])
+    found = self.wait_and_validate(uid, result, msg, perf, '%s/exec'%tag)
+    if retry and not found:
+      return self.submit_via_exec(encryption, source, status, msg, perf, tag, False)
     return result
 
   def test_one_crypto_full(self, encryption, state, key):
-    r1 = self.submit_payload(encryption, '%ssrc%s'%(key, key), state, '%smsg%s'%(key, key), '')
-    if r1:
-      return r1
-    result = TestResult()
-    result.add_message(True, '*FAILED* to send message with %s (retrying)'%encryption)
-    r2 = self.submit_payload(encryption, '%ssrc%s'%(key, key), state, '%smsg%s'%(key, key), '')
-    if r2:
-      result.add(r2)
-      return result
-    result.add_message(False, 'Failed to send message with uuid: %s'%encryption)
+    result = TestResult()
+    result.add(self.submit_payload(encryption, '%ssrc%s'%(key, key), state, '%smsg%s'%(key, key), '', '%s/%s'%(state, encryption)))
+    result.add(self.submit_via_exec(encryption, '%ssrc%s'%(key, key), state, '%smsg%s'%(key, key), '', '%s/%s'%(state, encryption)))
     return result
 
@@ -186 +207 @@
     core.reload('test_nsca_server')
     result = TestResult()
+    result.add_message(isOpen('localhost', 15667), 'Checking that port is open')
     result.add(self.test_one_crypto_full(crypto, status.UNKNOWN, 'unknown'))
     result.add(self.test_one_crypto_full(crypto, status.OK, 'ok'))
@@ -194 +216 @@
   def run_test(self):
     result = TestResult()
-    result.add_message(isOpen('localhost', 15667), 'Checking that port is open')
     # Currently broken: "xor"
     cryptos = ["des", "3des", "cast128", "xtea", "blowfish", "twofish", "rc2", "aes", "serpent", "gost", "none", "3way"]