gramps
373ebc8c93
952 days continuous production uptime, 40k+ tp/s single node. Original corpo Bitbucket history not included — clean archive commit.
653 lines
24 KiB
PHP
653 lines
24 KiB
PHP
<?php
|
|
/**
|
|
* This is the gasStatic class which is a collection of one-off functions that can be called from a broker or any
|
|
* instantiation class -- code herein is class-agnostic and storing one-off's here reduces the overhead of a full
|
|
* class instantiation to accomplish the same functionality.
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 06-09-17 mks original coding
|
|
* 08-28-17 mks CORE-494: removed buildMappedDataArray() -- method lives in the gasCache class
|
|
* 03-02-18 mks CORE-680: deprecated trace logging
|
|
* 07-30-18 mks CORE-774: PHP7.2 Exception handling
|
|
*
|
|
*/
|
|
|
|
class gasStatic
|
|
{
|
|
private static ?gasStatic $instance = null; // used to determine if already instantiated
|
|
private static string $res = 'STTK: '; // logging resource id
|
|
public static bool $debug; // debug state for diagnostic output
|
|
public static bool $available = false; // instantiation-check
|
|
private static ?array $errors; // local error stack
|
|
private static string $class; // name of the current class
|
|
private static ?gacErrorLogger $logger = null;
|
|
|
|
/**
|
|
* __construct() -- private function
|
|
*
|
|
* this is the constructor function for this singleton class. the constructor sets the class's member variables
|
|
* and calls any cache pre-loading that's required.
|
|
*
|
|
* Note that the public entry point is via the getInstance() method.
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 06-09-17 mks original coding
|
|
* 07-30-18 mks CORE-774: PHP7.2 Exception handling
|
|
*
|
|
*/
|
|
private function __construct()
|
|
{
|
|
global $eos;
|
|
|
|
static::$errors = null;
|
|
try {
|
|
static::$logger = new gacErrorLogger();
|
|
} catch (TypeError $t) {
|
|
echo getDateTime() . CON_ERROR . static::$res . $t->getMessage() . $eos;
|
|
static::$errors[] = $t->getMessage();
|
|
}
|
|
static::$class = __CLASS__;
|
|
static::$debug = (isset(gasConfig::$settings[STRING_DEBUG])) ? gasConfig::$settings[STRING_DEBUG] : false;
|
|
}
|
|
|
|
|
|
/**
|
|
* singleton() -- public static class
|
|
*
|
|
* method to instantiate the resourceManager singleton class
|
|
*
|
|
* note:
|
|
* -----
|
|
* it's the calling client's responsibility to check for the null return value in the member variable $instance.
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
* @return null
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 06-09-17 mks original coding
|
|
*
|
|
*/
|
|
public static function singleton()
|
|
{
|
|
if (static::$instance === null) {
|
|
$c = __CLASS__;
|
|
static::$instance = new $c();
|
|
}
|
|
return(static::$instance);
|
|
}
|
|
|
|
|
|
/**
|
|
* getInstance() -- public static method
|
|
*
|
|
* this is the singleton constructor entry point for the class. returns a resource pointer to the static or
|
|
* a null value if the instantiation failed.
|
|
*
|
|
* USAGE:
|
|
* ------
|
|
* $resourcePointer = pgsStatic::getInstance();
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
* @return mixed
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 06-09-17 mks original coding
|
|
*
|
|
*/
|
|
public static function getInstance()
|
|
{
|
|
if (static::$instance === null) {
|
|
$c = __CLASS__;
|
|
static::$instance = new $c();
|
|
}
|
|
return (static::$instance);
|
|
}
|
|
|
|
|
|
/**
|
|
* doingTime() -- public static method
|
|
*
|
|
* public static method that creates a timer (micro-time) value.
|
|
*
|
|
* _start is the input parameter (defaults to Boolean(false)) -- if this value is false, then the method will
|
|
* immediately return a generated timer value to the client.
|
|
*
|
|
* if _start is provided, then get a second timer value and derive the difference between the current and the
|
|
* start-time returning the total time calculated.
|
|
*
|
|
* USAGE:
|
|
* ------
|
|
* pgsStatic::getInstance()->doingTime($startValue);
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
* @param integer $_start
|
|
* @return float|int
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 06-09-17 mks original coding
|
|
*
|
|
*/
|
|
public static function doingTime(int $_start = 0)
|
|
{
|
|
if ($_start == 0) {
|
|
return (time() + microtime(true));
|
|
}
|
|
$end = time() + microtime(true);
|
|
return (round(floatval($end - floatval($_start)), NUMBER_FP_PRECISION));
|
|
}
|
|
|
|
|
|
/**
|
|
* publishSystemEvent() -- public method
|
|
*
|
|
* This method is invoked when we want to publish a system event to the (remote) admin service. The method requires
|
|
* a single input parameter: the data ball in array format which represents one, or more, broker event records.
|
|
*
|
|
* The method is responsible for ensuring the data ball is in the correct format (an array of records), and for
|
|
* building the payload that's published to the admin service.
|
|
*
|
|
* The method returns a false on processing error, or if the packet fails to send. A true return means that the
|
|
* payload was successfully submitted to the (remote) service. It does not indicate that the record was
|
|
* successfully processed and inserted into the collection as that part of the process is black-boxed behind RMQ.
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
* @param array $_data the record to be published remotely
|
|
* @param array $_meta the meta data for the sysEvent record to be published
|
|
* @param string $_og the original event guid
|
|
* @param array|null $_es call-by-reference parameter to contain the error stack
|
|
* @return bool
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 08-17-17 mks CORE-500: original coding
|
|
* 08-13-20 mks DB-168: method renamed, meta added to params, refactored, and moved to gasStatic class
|
|
*
|
|
*/
|
|
public static function publishSystemEvent(array $_data, array $_meta, string $_og = '', ?array $_es = null): bool
|
|
{
|
|
$bc = null;
|
|
// validate that the $_data payload is not empty
|
|
if (empty($_data)) {
|
|
$msg = ERROR_DATA_ARRAY_EMPTY . COLON . STRING_DATA;
|
|
$_es[] = $msg;
|
|
return false;
|
|
}
|
|
if (empty($_meta)) {
|
|
$msg = ERROR_DATA_ARRAY_EMPTY . COLON . STRING_META;
|
|
$_es[] = $msg;
|
|
return false;
|
|
}
|
|
// validate that we're getting an array of records ($_data[0] = record1, etc.)
|
|
if (key($_data) !== 0) {
|
|
$msg = ERROR_DATA_ARRAY_NOT_ARRAY . STRING_DATA;
|
|
$_es[] = $msg;
|
|
return false;
|
|
}
|
|
try {
|
|
// instantiate an AI broker client
|
|
$bc = static::fetchAIClient($_es);
|
|
if (is_null($bc)) return false;
|
|
|
|
if (!empty($_og) and validateGUID($_og)) $_meta[META_EVENT_GUID] = $_og;
|
|
$request = [
|
|
BROKER_REQUEST => BROKER_REQUEST_ADMIN_BROKER_EVENT,
|
|
BROKER_DATA => $_data,
|
|
BROKER_META_DATA => $_meta
|
|
];
|
|
$response = $bc->call(gzcompress(json_encode($request))); // rpc queue
|
|
if (is_object($bc)) $bc->__destruct();
|
|
unset($bc);
|
|
return ($response);
|
|
} catch (Throwable $t) {
|
|
$hdr = sprintf(INFO_LOC, basename(__METHOD__), __LINE__);
|
|
@handleExceptionMessaging($hdr, $t->getMessage(), $_es);
|
|
if (is_object($bc)) $bc->__destruct();
|
|
unset($bc);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* fetchAIClient() -- private method
|
|
*
|
|
* This method instantiates a new AdminIN broker client and assigns the object to the $aiClient property.
|
|
*
|
|
* The method checks to see if there's already an object attached before instantiating a new one.
|
|
*
|
|
* The method returns a BOOL value that indicates if the instantiation was successful or not.
|
|
*
|
|
*
|
|
* @param array|null $_es -- call-by-reference parameter containing the method's error stack output
|
|
* @return null|gacWorkQueueClient
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 08-17-17 mks CORE-500: original coding
|
|
* 09-10-20 mks DB-168: improved error handling, moved to static class, changed return type to obj
|
|
*
|
|
*@author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
*/
|
|
private static function fetchAIClient(?array &$_es):?gacWorkQueueClient
|
|
{
|
|
$bc = null;
|
|
$foo = null;
|
|
$method = basename(__METHOD__);
|
|
try {
|
|
$bc = new gacWorkQueueClient($method . AT . __LINE__);
|
|
if (!$bc->status) {
|
|
$hdr = sprintf(INFO_LOC, $method, __LINE__);
|
|
$msg = ERROR_FAILED_TO_INSTANTIATE . RESOURCE_ADMIN_CLIENT;
|
|
$_es[] = $msg;
|
|
static::$logger->error($hdr . $msg);
|
|
if (is_object($bc)) $bc->__destruct();
|
|
unset($bc);
|
|
return null;
|
|
}
|
|
return $bc;
|
|
} catch (Throwable | TypeError $t) {
|
|
$hdr = sprintf(INFO_LOC, $method, __LINE__);
|
|
$_es[] = ERROR_THROWABLE_EXCEPTION;
|
|
@handleExceptionMessaging($hdr, $t->getMessage(), $foo, true);
|
|
if (is_object($bc)) $bc->__destruct();
|
|
unset($bc);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* createATJob() -- public static method
|
|
*
|
|
* this is a private method providing a single point-of-access to the create-AT-Job function. the method requires
|
|
* the following input parameters:
|
|
*
|
|
* -- duration (in seconds) from "now" when the session will expire
|
|
* -- the systemEvent token that will be passed to the PHP script, invoked by AT(1)
|
|
* -- $_script - should be one of two values: used the session script for backward compatibility
|
|
*
|
|
* since this is an internal method, there's no error checking or parameter validation - this method will only
|
|
* execute if the admin service is local to the current instance.
|
|
*
|
|
* the function returns the AT output back to the calling client as a string or a null if the admin service is not
|
|
* local to the current instance or if an exception was raised during processing.
|
|
*
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
* @param int $_duration
|
|
* @param string $_sysEvToken
|
|
* @param string $_script
|
|
* @return null | string
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 08-13-20 mks DB-168: original coding
|
|
*
|
|
*/
|
|
public static function createATJob(int $_duration, string $_sysEvToken, string $_script = FILE_EOS):?string
|
|
{
|
|
if (gasConfig::$settings[ENV_ADMIN][CONFIG_IS_LOCAL]) {
|
|
$time = 'now + ' . floor($_duration / NUMBER_SECS_IN_MIN) . ' ' . STRING_SYS_MIN;
|
|
$job = '/usr/bin/php -f ' . dirname(__DIR__) . DIR_SCRIPTS . $_script . ' ' . $_sysEvToken;
|
|
return (gacATWrapper::cmd($job, $time));
|
|
} else {
|
|
try {
|
|
$hdr = sprintf(INFO_LOC, basename(__METHOD__), __LINE__);
|
|
$msg = ERROR_REMOTE_NOT_ADMIN;
|
|
static::$logger->warn($hdr . $msg);
|
|
consoleLog(static::$res, CON_ERROR, $msg);
|
|
} catch (TypeError | Throwable $t) {
|
|
$hdr = sprintf(INFO_LOC, basename(__METHOD__), __LINE__);
|
|
static::$logger->warn($hdr . $t->getMessage());
|
|
consoleLog(static::$res, CON_ERROR, $t->getMessage());
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* convertWebMigrationRequest() -- public static method
|
|
*
|
|
* This function is called from the migration broker when we receive a migration request from the webUI.
|
|
*
|
|
* There is one input parameter for this method:
|
|
*
|
|
* $_data -- the array passed from the broker which contains the event payload data
|
|
*
|
|
* The method returns an array -- this array will contain a new configuration matrix to temporarily replace
|
|
* gasConfig::$settings[CONFIG_MIGRATION].
|
|
*
|
|
* The method generates a copy of the migration XML data and then over-writes relevant fields with data received
|
|
* via the input parameters.
|
|
*
|
|
* No validation is performed as the web-app (./utilities/migrateData.php) does all the data validation prior
|
|
* to publishing the broker event request.
|
|
*
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
*
|
|
* @param array $_data -- broker event payload data
|
|
* @return array -- returns a replacement migration configuration (data validated/tested in web-app!)
|
|
*
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 09-27-18 mks DB-43: initial coding
|
|
*
|
|
*/
|
|
public static function convertWebMigrationRequest(array $_data): array
|
|
{
|
|
$rd = null; // return data
|
|
$newMigCfg = gasConfig::$settings[CONFIG_MIGRATION]; // start with a copy of the current config
|
|
|
|
// first, set the schema
|
|
$schema = $_data[MIGRATION_SOURCE_SCHEMA];
|
|
// next, let's replace the common migration XML components that are required in an override-migration request
|
|
$newMigCfg[$schema][STRING_HOST] = $_data[STRING_HOST];
|
|
$newMigCfg[$schema][STRING_PORT] = $_data[STRING_PORT];
|
|
$newMigCfg[$schema][CONFIG_DATABASE] = $_data[CONFIG_DATABASE];
|
|
|
|
// next, if the optional components are set, bring them into the new config array
|
|
if (isset($_data[STRING_USER])) $newMigCfg[$schema][STRING_USER] = $_data[STRING_USER];
|
|
if (isset($_data[STRING_PASS])) $newMigCfg[$schema][STRING_PASS] = $_data[STRING_PASS];
|
|
|
|
// next, grab the mongo-specific components
|
|
if ($schema == CONFIG_SCHEMA_MONGO) {
|
|
$newMigCfg[$schema][STRING_AUTH_SRC] = $_data[STRING_AUTH_SRC];
|
|
$newMigCfg[$schema][CONFIG_DATABASE_MONGODB_REPLSET_NAME] = $_data[CONFIG_DATABASE_MONGODB_REPLSET_NAME];
|
|
$newMigCfg[$schema][CONFIG_DATABASE_MONGODB_REPLSET_DSN] = $_data[CONFIG_DATABASE_MONGODB_REPLSET_DSN];
|
|
}
|
|
return $newMigCfg;
|
|
}
|
|
|
|
|
|
/**
|
|
* loadValidTemplateNames() -- private method
|
|
*
|
|
* this method loads all of the file names that end with an ".inc" extension that currently reside in the
|
|
* framework's template directory.
|
|
*
|
|
* The file names are loaded into the indexed array and returned to the calling client.
|
|
*
|
|
* If we could not open the template directory, then the value for $validTemplates is set to null - which
|
|
* should be tested by the client on return.
|
|
*
|
|
* Additionally, if the template files could not be loaded, we generate both a diagnostics and a logging
|
|
* error message.
|
|
*
|
|
* There are no inputs to this method. The method returns an array of valid template names it sussed from the
|
|
* template directory, on success, or a null on failure.
|
|
*
|
|
* @author mike@givingassistant.com
|
|
* @version 1.0
|
|
*
|
|
* @return array|null
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 06-15-17 mks original coding
|
|
* 07-07-17 mks fixed error searching for .inc type files
|
|
* 07-30-18 mks CORE-775: PHP7.2 Exception Handling
|
|
* 09-13-18 mks DB-43: added option to strip "gat" prepend
|
|
* 06-11-20 mks ECI-164: can no longer strip the TLTI prefix from template classes
|
|
*
|
|
*/
|
|
public static function loadValidTemplateNames(): ?array
|
|
{
|
|
$validTemplates = null;
|
|
$tDir = __DIR__ . DIR_TEMPLATE;
|
|
if ($fh = opendir($tDir)) {
|
|
while (false !== ($file = readdir($fh))) {
|
|
if ($file != DOT and $file != DOTDOT and (substr($file, (strlen($file) - strlen(FILE_TYPE_INC))) == FILE_TYPE_INC)) {
|
|
$validTemplates[] = preg_replace("/" . FILE_TEMPLATE_EXT . "/", "", $file);
|
|
}
|
|
}
|
|
closedir($fh);
|
|
} else {
|
|
$msg = ERROR_READ_DIR . $tDir;
|
|
static::$logger->warn($msg);
|
|
}
|
|
return($validTemplates);
|
|
}
|
|
|
|
|
|
/**
|
|
* getTLTI() -- public static method
|
|
*
|
|
* This method was moved from gacFactory class to gasStatic class because the factory is not the only place where
|
|
* we need to derive a TLTI based on a meta-data payload - this method will also be called from every broker
|
|
* class when validating an incoming meta-data payload prior to the gacFactory instantiation.
|
|
*
|
|
* The method has the following input parameters:
|
|
*
|
|
* $_authToken -- this is the CLIENT_AUTH_TOKEN as received from the SMAX-request meta-data payload
|
|
* $_eventGUID -- as above, except META_EVENT_GUID
|
|
* $_payload -- call-by-reference parameter, will implicitly return the broker response payload
|
|
*
|
|
* We instantiate a read-broker client and, on success, build our query to fetch the TLTI from the SMAXAPI
|
|
* data table in appServer. We'll exec the request as a system-level request to bypass redundant validation
|
|
* checks speeding up the process.
|
|
*
|
|
* Next, we publish the request and consume the response -- if the event was successful, then we'll extract
|
|
* the tlti from the payload and explicitly return that value.
|
|
*
|
|
* In all other cases, the function returns a null value to indicate a processing error. It's the responsibility
|
|
* of the calling client to process the error which is why we implicitly return the response payload.
|
|
*
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
* @param string $_authToken
|
|
* @param string $_eventGUID
|
|
* @param array|null $_payload
|
|
* @return string|null
|
|
*
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 06-15-20 mks ECI-164: original coding as a tweaked-import from the gacFactory class
|
|
*
|
|
*/
|
|
public static function getTLTI(string $_authToken, string $_eventGUID, ?array &$_payload = null):?string
|
|
{
|
|
// instantiate a read-broker client to fetch the TLTI for the AUTH TOKEN
|
|
if (is_null($bc = static::getBC(BROKER_QUEUE_R, sprintf(INFO_LOC, basename(__FILE__), __LINE__)))) return null;
|
|
$query = [STRING_KEY => [OPERAND_NULL => [OPERATOR_EQ => [$_authToken]]]];
|
|
$request = [
|
|
BROKER_REQUEST => BROKER_REQUEST_FETCH,
|
|
BROKER_DATA => [
|
|
STRING_QUERY_DATA => $query,
|
|
STRING_RETURN_DATA => [CM_SMAX_TLTI]
|
|
],
|
|
BROKER_META_DATA => [
|
|
META_CLIENT => CLIENT_SYSTEM,
|
|
META_DO_CACHE => false,
|
|
META_TEMPLATE => TEMPLATE_CLASS_SMAXAPI,
|
|
META_EVENT_GUID => $_eventGUID
|
|
]
|
|
];
|
|
// publish the payload request and consume the Namaste response
|
|
$response = json_decode(gzuncompress($bc->call(gzcompress(json_encode($request)))), true);
|
|
if (is_object($bc)) $bc->__destruct();
|
|
unset($bc);
|
|
$_payload = $response;
|
|
if ($response[PAYLOAD_STATUS] and $response[PAYLOAD_STATE] != STATE_NOT_FOUND) {
|
|
if (isset($response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS][0][SMAX_TLTI])) {
|
|
return $response[PAYLOAD_RESULTS][STRING_QUERY_RESULTS][0][SMAX_TLTI] . CHAR_T;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
/**
|
|
* getBC() -- private static method
|
|
*
|
|
* This method was originally in the Factory class but was moved to the static class because of the broker calls
|
|
* to validateMetaData also requires deriving the TLTI based on the META_CLIENT setting.
|
|
*
|
|
* This method fetches a valid broker client connecting to the appServer read broker. Since the instantiation
|
|
* is exception wrapped, the call here is not.
|
|
*
|
|
* The method requires the following two input parameters:
|
|
*
|
|
* $_queue -- the name of the broker queue to instantiate
|
|
* $_loc -- the INFO_LOC string which is passed to rabbit so as to identify where the request originated
|
|
*
|
|
* The method returns a gacBrokerClient object or, in the case of an error raised during instantiation, a null.
|
|
*
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
* @param string $_queue
|
|
* @param string $_loc
|
|
* @return gacBrokerClient|null
|
|
*
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 06-15-20 mks ECI-164: original coding
|
|
*
|
|
*/
|
|
private static function getBC(string $_queue, string $_loc):?gacBrokerClient
|
|
{
|
|
$file = sprintf(INFO_LOC, basename(__METHOD__), __LINE__);
|
|
$bc = new gacBrokerClient($_queue, $_loc);
|
|
if (!$bc->status) {
|
|
// failed to instantiate a broker client
|
|
$hdr = sprintf(INFO_LOC, $file, __LINE__);
|
|
$msg = ERROR_BROKER_CLIENT_DECLARE . BROKER_QUEUE_R;
|
|
consoleLog(static::$res, CON_SYSTEM, $hdr . $msg);
|
|
static::$errors[] = $hdr . $msg;
|
|
if (is_object($bc)) $bc->__destruct();
|
|
unset($bc);
|
|
return null;
|
|
}
|
|
return $bc;
|
|
}
|
|
|
|
|
|
/**
|
|
* buildPDODBName() -- public static method
|
|
*
|
|
* This method requires a single argument to the function:
|
|
*
|
|
* $_env: should be either ENV_PRIME, ENV_SEGUNDO or any of the other valid env names
|
|
*
|
|
* The purpose of this function is to generate the database name during run time which is predicated on the
|
|
* current running environment and the current namaste service on which this is running.
|
|
*
|
|
* If an invalid or unsupported env is passed to the method, it will return a null. Otherwise, the method builds
|
|
* the db name and returns that to the calling client.
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
* @param string $_env
|
|
* @return string|null
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 08-20-19 mks DB-
|
|
*/
|
|
public static function buildPDODBName(string $_env): ?string
|
|
{
|
|
$dbConfig = gasConfig::$settings[CONFIG_DATABASE][CONFIG_DATABASE_PDO];
|
|
|
|
// if more env's are defined to support PDO, you will have to also define them here.
|
|
switch ($_env) {
|
|
case ENV_APPSERVER :
|
|
$namastePDO = $dbConfig[CONFIG_DATABASE_PDO_APPSERVER][CONFIG_DATABASE_PDO_MASTER][CONFIG_DATABASE_PDO_DB];
|
|
break;
|
|
case ENV_SEGUNDO :
|
|
$namastePDO = $dbConfig[CONFIG_DATABASE_PDO_SEGUNDO][CONFIG_DATABASE_PDO_MASTER][CONFIG_DATABASE_PDO_DB];
|
|
break;
|
|
default :
|
|
consoleLog(static::$res, CON_ERROR, sprintf(ERROR_RESOURCE_ENV_404, STRING_PDO, $_env));
|
|
return null;
|
|
break;
|
|
}
|
|
return gasConfig::$settings[CONFIG_ID][CONFIG_ID_ENV] . UDASH . $namastePDO;
|
|
}
|
|
|
|
|
|
/**
|
|
* getSysLogError() -- public static method
|
|
*
|
|
* This method requires one input parameter:
|
|
*
|
|
* $_error: integer value representing the namaste error
|
|
*
|
|
* Namaste errors are mapped as follows:
|
|
*
|
|
* Namaste Error Value Syslog Error
|
|
* ---------------------------------------
|
|
* DEBUG 2 LOG_DEBUG
|
|
* DATA 3 LOG_NOTICE
|
|
* INFO 4 LOG_INFO
|
|
* ERROR 5 LOG_ERROR
|
|
* WARN 6 LOG_CRIT
|
|
* FATAL 7 LOG_EMERG
|
|
*
|
|
* TRACE used to be Value = 1 but has since been deprecated.
|
|
* METRICS has a Value of 0.
|
|
* EVENT has a value of -1.
|
|
*
|
|
* We create a simple matrix with the Namaste values as keys and the sysLog values as values and then map the
|
|
* input value passed in $_error via the matrix. If not found, then we return a LOG_ERR syslog code. Otherwise,
|
|
* return the mapped integer value.
|
|
*
|
|
*
|
|
* @author mike@givingassistant.org
|
|
* @version 1.0
|
|
*
|
|
* @param int $_error
|
|
* @return int
|
|
*
|
|
* HISTORY:
|
|
* ========
|
|
* 09-26-19 mks DB-136: original coding
|
|
*
|
|
*/
|
|
public static function getSysLogError(int $_error): int
|
|
{
|
|
$matrix = [
|
|
2 => LOG_DEBUG,
|
|
3 => LOG_NOTICE,
|
|
4 => LOG_INFO,
|
|
5 => LOG_ERR,
|
|
6 => LOG_CRIT,
|
|
7 => LOG_EMERG
|
|
];
|
|
return (!array_key_exists($_error, $matrix)) ? LOG_ERR : $matrix[$_error];
|
|
}
|
|
} |