Блог

У меня есть служба Windows, адаптированная из

https://learn.microsoft.com/en-us/windows/win32/services/the-complete-service-sample?redirectedfrom=MSDN

это обычно запускается / останавливается при выполнении простой задачи, такой как запись в цикле while в текстовый файл, как в этом примере

 
#include <windows.h>
#include <string>
#include "service.hh"
#include "log.hh"

LPSTR service_name = "_service_test";
std::string log_program_name("M:\"   std::string(service_name));

VOID WINAPI service_main(DWORD, LPTSTR*);
void write_txt_file(const std::stringamp; file_name, const std::stringamp; input);

SERVICE_STATUS_HANDLE service_handle = NULL;
HANDLE service_stop_event = INVALID_HANDLE_VALUE;
DWORD current_state = 0;

/////////////////////////////////////////////////////////////////////////////////////////////////////
//main
//create service in administrator shell with
//sc create _service_test binPath= "L:netbuildDebugtest_service.exe"
/////////////////////////////////////////////////////////////////////////////////////////////////////

int main(int argc, char* argv[])
{
  events::start_log();

  //A service process has a SERVICE_TABLE_ENTRY structure for each service that it can start. 
  //The structure specifies the service name and a pointer to the service main function for that service.
  //The main function of a service program calls the StartServiceCtrlDispatcher 
  //function to connect to the service control manager (SCM)

  SERVICE_TABLE_ENTRY service_table[] =
  {
      { service_name, (LPSERVICE_MAIN_FUNCTION)service_main },
      { NULL, NULL }
  };

  if (StartServiceCtrlDispatcher(service_table))
  {
    return 0;
  }
  else
  {
    return 1;
  }
}

void WINAPI service_main(DWORD argc, LPTSTR* argv)
{
  service_handle = RegisterServiceCtrlHandler(service_name, service_handler);
  if (service_handle == NULL)
  {
    return;
  }

  report_status(SERVICE_START_PENDING);

  events::log("service start pending..."   std::to_string(current_state));

  service_stop_event = CreateEvent(NULL, TRUE, FALSE, NULL);
  if (service_stop_event == NULL)
  {
    return;
  }

  report_status(SERVICE_RUNNING);

  events::log("service running..."   std::to_string(current_state));

  int i = 0;

  while (WaitForSingleObject(service_stop_event, 1000) != WAIT_OBJECT_0)
  {
    write_txt_file("M:\log.txt", "writing...#"   std::to_string(i));
    Sleep(1000);
    i  ;
  }

  report_status(SERVICE_STOP_PENDING);
  events::log("service stop pending..."   std::to_string(current_state));
  CloseHandle(service_stop_event);
  report_status(SERVICE_STOPPED);
  events::log("service stopped..."   std::to_string(current_state));
}

void write_txt_file(const std::stringamp; file_name, const std::stringamp; input)
{
  FILE* f = fopen(file_name.c_str(), "a ");
  fprintf(f, "%sn", input.c_str());
  fclose(f);
}
  

это приводит к выводу журнала

 2020-09-05,14:18:03 service start pending...2
2020-09-05,14:18:03 service running...4
2020-09-05,14:18:20 service stop pending state...4
2020-09-05,14:18:21 service stop pending...3
2020-09-05,14:18:21 service stopped...1
  

Однако при использовании службы в качестве ASIO-сервера в блокирующем сокете, когда запрашивается остановка службы, она никогда не достигает состояния остановки, только ожидающего состояния остановки

сокращенный код сервера

 
asio::io_service io_service;
tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), port_num));

while (WaitForSingleObject(service_stop_event, 1000) != WAIT_OBJECT_0)
{
   
   tcp::socket sock(io_service);
   acceptor.accept(sock); /// blocking call

}

  

функции кода службы

 /////////////////////////////////////////////////////////////////////////////////////////////////////
//handles 
/////////////////////////////////////////////////////////////////////////////////////////////////////

extern SERVICE_STATUS_HANDLE service_handle;
extern  HANDLE service_stop_event;
extern  DWORD current_state;

/////////////////////////////////////////////////////////////////////////////////////////////////////
//service_handler
//handles stop service
/////////////////////////////////////////////////////////////////////////////////////////////////////

VOID WINAPI service_handler(DWORD code)
{
  switch (code)
  {
  case SERVICE_CONTROL_SHUTDOWN:
  case SERVICE_CONTROL_STOP:
    events::log("service stop pending state..."   std::to_string(current_state));
    report_status(SERVICE_STOP_PENDING);
    SetEvent(service_stop_event);
    break;
  default:
    events::log("service running state..."   std::to_string(current_state));
    report_status(current_state);
    break;
  }
  return;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////
//report_status
/////////////////////////////////////////////////////////////////////////////////////////////////////

void report_status(DWORD state)
{
  current_state = state;
  SERVICE_STATUS service_status = {
      SERVICE_WIN32_OWN_PROCESS,
      current_state,
      state == SERVICE_START_PENDING ? 0 : SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN,
      NO_ERROR,
      0,
      0,
      0,
  };

  if (SetServiceStatus(service_handle, amp;service_status) == FALSE)
  {
    return;
  }
}
  

Решается путем отправки «фиктивного» самостоятельного запроса на сервер, который разблокирует acceptor.accept(sock);

 SetEvent(service_stop_event);
send_close(port);
  

где завершающий вызов

 
/////////////////////////////////////////////////////////////////////////////////////////////////////
//temporary client connection to self on localhost to unblock acceptor.accept()
/////////////////////////////////////////////////////////////////////////////////////////////////////

void http::send_close(const std::stringamp; port_num)
{
  asio::io_service io_service;
  asio::ip::tcp::resolver resolver(io_service);
  asio::ip::tcp::socket socket(io_service);
  asio::connect(socket, resolver.resolve("127.0.0.1", port_num));
  std::string request("GET /stop_service HTTP/1.1rnrn");
  asio::write(socket, asio::buffer(request, request.size()));
  socket.shutdown(asio::ip::tcp::socket::shutdown_both);
  socket.close();
  events::log("sent GET /stop_service");
}