src/cppcache/src/statistics/GeodeStatisticsFactory.cpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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
 *
 *      http://www.apache.org/licenses/LICENSE-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 <gfcpp/gfcpp_globals.hpp>

#include <ace/Recursive_Thread_Mutex.h>
#include <ace/OS.h>
#include <ace/Thread_Mutex.h>
#include <ace/Guard_T.h>
#include <gfcpp/Exception.hpp>
#include "GeodeStatisticsFactory.hpp"
#include <gfcpp/Log.hpp>
#include <string>
#include "AtomicStatisticsImpl.hpp"
#include "OsStatisticsImpl.hpp"
#include "HostStatHelper.hpp"

using namespace apache::geode::client;
using namespace apache::geode::statistics;

/**
 * static member initialization
 */
GeodeStatisticsFactory* GeodeStatisticsFactory::s_singleton = NULL;

GeodeStatisticsFactory::GeodeStatisticsFactory(StatisticsManager* statMngr) {
  m_name = "GeodeStatisticsFactory";
  m_id = ACE_OS::getpid();
  m_statsListUniqueId = 1;

  m_statMngr = statMngr;
}

GeodeStatisticsFactory* GeodeStatisticsFactory::initInstance(
    StatisticsManager* statMngr) {
  if (!s_singleton) {
    s_singleton = new GeodeStatisticsFactory(statMngr);
  }

  return s_singleton;
}

GeodeStatisticsFactory* GeodeStatisticsFactory::getExistingInstance() {
  GF_D_ASSERT(!!s_singleton);

  s_singleton->getId();  // should fault if !s_singleton

  return s_singleton;
}

/**************************Dtor*******************************************/
void GeodeStatisticsFactory::clean() {
  if (s_singleton != NULL) {
    delete s_singleton;
    s_singleton = NULL;
  }
}

GeodeStatisticsFactory::~GeodeStatisticsFactory() {
  try {
    m_statMngr = NULL;

    // Clean Map : Delete all the pointers of StatisticsType from the map.
    if (statsTypeMap.total_size() == 0) return;

    ACE_Map_Manager<std::string, StatisticsTypeImpl*,
                    ACE_Recursive_Thread_Mutex>::iterator iterFind =
        statsTypeMap.begin();
    while (iterFind != statsTypeMap.end()) {
      delete (*iterFind).int_id_;
      (*iterFind).int_id_ = NULL;
      iterFind++;
    }
    statsTypeMap.unbind_all();

  } catch (const Exception& ex) {
    Log::warningCatch("~GeodeStatisticsFactory swallowing Geode exception", ex);

  } catch (const std::exception& ex) {
    std::string what = "~GeodeStatisticsFactory swallowing std::exception: ";
    what += ex.what();
    LOGWARN(what.c_str());

  } catch (...) {
    LOGERROR("~GeodeStatisticsFactory swallowing unknown exception");
  }
}

const char* GeodeStatisticsFactory::getName() { return m_name; }

int64 GeodeStatisticsFactory::getId() { return m_id; }

Statistics* GeodeStatisticsFactory::createStatistics(StatisticsType* type) {
  return createAtomicStatistics(type, NULL, 0);
}

Statistics* GeodeStatisticsFactory::createStatistics(StatisticsType* type,
                                                     const char* textId) {
  return createAtomicStatistics(type, textId, 0);
}

Statistics* GeodeStatisticsFactory::createStatistics(StatisticsType* type,
                                                     const char* textId,
                                                     int64 numericId) {
  return createAtomicStatistics(type, textId, 0);
}

Statistics* GeodeStatisticsFactory::createOsStatistics(StatisticsType* type,
                                                       const char* textId,
                                                       int64 numericId) {
  // Validate input
  if (type == NULL) {
    throw IllegalArgumentException("StatisticsType* is Null");
  }

  int64 myUniqueId;
  {
    ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_statsListUniqueIdLock);
    myUniqueId = m_statsListUniqueId++;
  }

  Statistics* result =
      new OsStatisticsImpl(type, textId, numericId, myUniqueId, this);
  { m_statMngr->addStatisticsToList(result); }

  return result;
}

Statistics* GeodeStatisticsFactory::createAtomicStatistics(
    StatisticsType* type) {
  return createAtomicStatistics(type, NULL, 0);
}

Statistics* GeodeStatisticsFactory::createAtomicStatistics(StatisticsType* type,
                                                           const char* textId) {
  return createAtomicStatistics(type, textId, 0);
}

Statistics* GeodeStatisticsFactory::createAtomicStatistics(StatisticsType* type,
                                                           const char* textId,
                                                           int64 numericId) {
  // Validate input
  if (type == NULL) {
    throw IllegalArgumentException("StatisticsType* is Null");
  }
  int64 myUniqueId;

  {
    ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_statsListUniqueIdLock);
    myUniqueId = m_statsListUniqueId++;
  }

  Statistics* result =
      new AtomicStatisticsImpl(type, textId, numericId, myUniqueId, this);

  { m_statMngr->addStatisticsToList(result); }

  return result;
}

Statistics* GeodeStatisticsFactory::findFirstStatisticsByType(
    StatisticsType* type) {
  return (m_statMngr->findFirstStatisticsByType(type));
}

StatisticsTypeImpl* GeodeStatisticsFactory::addType(StatisticsTypeImpl* st) {
  StatisticsTypeImpl* st1;
  std::string temp(st->getName());
  int status;
  try {
    status = statsTypeMap.rebind(temp, st, st1);
  } catch (const std::exception& ex) {
    throw IllegalArgumentException(ex.what());
  } catch (...) {
    throw IllegalArgumentException("addType: unknown exception");
  }
  if (status == 1) {
  } else if (status == -1) {
    throw IllegalArgumentException(
        "GeodeStatisticsFactory::addType: failed "
        "to add new type %s",
        temp.c_str());
  }
  return st;
}

/**
 * Creates  a StatisticType for the given shared class.
 */
StatisticsType* GeodeStatisticsFactory::createType(const char* name,
                                                   const char* description,
                                                   StatisticDescriptor** stats,
                                                   int32 statsLength) {
  StatisticsTypeImpl* st =
      new StatisticsTypeImpl(name, description, stats, statsLength);

  if (st != NULL) {
    st = addType(st);
  } else {
    throw OutOfMemoryException(
        "GeodeStatisticsFactory::createType :: out memory");
  }
  return st;
}

StatisticsType* GeodeStatisticsFactory::findType(const char* name) {
  std::string statName = name;
  StatisticsTypeImpl* st = NULL;
  int status = statsTypeMap.find(statName, st);
  if (status == -1) {
    std::string temp(name);
    std::string s = "There is no statistic named \"" + temp + "\"";
    // LOGWARN(s.c_str());
    // throw IllegalArgumentException(s.c_str());
    return NULL;
  } else {
    return st;
  }
}

StatisticDescriptor* GeodeStatisticsFactory::createIntCounter(
    const char* name, const char* description, const char* units,
    int8 largerBetter) {
  return StatisticDescriptorImpl::createIntCounter(name, description, units,
                                                   largerBetter);
}

StatisticDescriptor* GeodeStatisticsFactory::createLongCounter(
    const char* name, const char* description, const char* units,
    int8 largerBetter) {
  return StatisticDescriptorImpl::createLongCounter(name, description, units,
                                                    largerBetter);
}

StatisticDescriptor* GeodeStatisticsFactory::createDoubleCounter(
    const char* name, const char* description, const char* units,
    int8 largerBetter) {
  return StatisticDescriptorImpl::createDoubleCounter(name, description, units,
                                                      largerBetter);
}

StatisticDescriptor* GeodeStatisticsFactory::createIntGauge(
    const char* name, const char* description, const char* units,
    int8 largerBetter) {
  return StatisticDescriptorImpl::createIntGauge(name, description, units,
                                                 largerBetter);
}

StatisticDescriptor* GeodeStatisticsFactory::createLongGauge(
    const char* name, const char* description, const char* units,
    int8 largerBetter) {
  return StatisticDescriptorImpl::createLongGauge(name, description, units,
                                                  largerBetter);
}

StatisticDescriptor* GeodeStatisticsFactory::createDoubleGauge(
    const char* name, const char* description, const char* units,
    int8 largerBetter) {
  return StatisticDescriptorImpl::createDoubleGauge(name, description, units,
                                                    largerBetter);
}