service/service.cc

Go to the documentation of this file.

/*
 * Copyright 2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <ssrc/wispers/service/service.h>
#include <ssrc/wispers/utility/BindProperties.h>
#include <ssrc/wispers/utility/memusage.h>

#include <algorithm>

#include <unistd.h>
#include <sys/resource.h>
#include <sys/utsname.h>
#include <sys/times.h>

__BEGIN_NS_SSRC_WSPR_SERVICE

#if defined(WISPERS_HAVE_GET_MEMUSAGE)
using NS_SSRC_WSPR_UTILITY::memusage;
using NS_SSRC_WSPR_UTILITY::get_memusage;
using NS_SSRC_WSPR_UTILITY::BindProperties;
#endif

using NS_SSRC_WSPR_UTILITY::Properties;
using NS_SSRC_WSPR_UTILITY::primitive_property_vector;

properties_ptr ServiceProtocolProcessor::get_status() {
  properties_ptr props = properties_ptr(new Properties);
  Properties *status   = props->create_node("srv");
  const ::pid_t pid = ::getpid();

  status->set(_caller.name(), "name");
  status->set(::getuid(), "uid");
  status->set(::getgid(), "gid");
  status->set(::geteuid(), "euid");
  status->set(::getegid(), "egid");
  status->set(pid, "pid");
  status->set(context().count_timeouts(), "timeouts");

  ::tms cputime;

  if(::times(&cputime) != -1) {
    long result = ::sysconf(_SC_CLK_TCK);
    if(result > 0) {
      double ticks_per_second = static_cast<double>(result);
      status->set(static_cast<double>(cputime.tms_utime)/ticks_per_second,
                  "utime");
      status->set(static_cast<double>(cputime.tms_stime)/ticks_per_second,
                  "stime");
      status->set(static_cast<double>(cputime.tms_cutime)/ticks_per_second,
                  "cutime");
      status->set(static_cast<double>(cputime.tms_cstime)/ticks_per_second,
                  "cstime");

    }
  }

  primitive_property_vector & service_types =
    status->create_primitive_property_vector("types");

  for(service_type_iterator it = service_types_begin(),
        end = service_types_end(); it != end; ++it) {
    service_types.push_back(*it);
  }

  struct utsname u_name;

  if(::uname(&u_name) > -1) {
    Properties *node = props->create_node("node");

    node->set<string>(u_name.sysname, "sysname");
    node->set<string>(u_name.nodename, "nodename");
    node->set<string>(u_name.release, "release");
    node->set<string>(u_name.version, "version");
    node->set<string>(u_name.machine, "machine");
  }

#if defined(WISPERS_HAVE_GET_MEMUSAGE)
  memusage musage;

  if(get_memusage(pid, musage)) {
    musage.visit(BindProperties(*status->create_node("memusage")));
  }
#endif

  status = status->create_node("caller");

  status->set(_caller.initial_message_capacity(), "initial_message_capacity");
  status->set(_caller.message_capacity(), "message_capacity");
  status->set(_caller.request_queue_size(), "request_queue_size");
  status->set(_caller.response_map_size(), "response_map_size");
  status->set(_caller.count_jumbo_messages(), "jumbo_messages");
  status->set(_caller.group_membership(), "group_membership");
  status->set(_caller.continuations_map_size(), "continuations_map_size");

  return props;
}

void ServiceProtocolProcessor::process_request(const MessageStatusRequest & msg,
                                               const MessageInfo & msginfo)
{
  _caller.send<CallStatusReply>(Message::FIFOSelfDiscard,
                                msginfo.sender(), get_status());
}

__END_NS_SSRC_WSPR_SERVICE