def setUp(self):
"""
Setup (called before each test)
"""
SolBase._reset()
# Check
self.assertFalse(SolBase._voodoo_initialized)
self.assertFalse(SolBase._logging_initialized)
# Initialize without logging
SolBase.voodoo_init(init_logging=False)
self.assertTrue(SolBase._voodoo_initialized)
self.assertFalse(SolBase._logging_initialized)
# Re-call => logging must kick in
SolBase.voodoo_init()
self.assertTrue(SolBase._voodoo_initialized)
self.assertTrue(SolBase._logging_initialized)
SolBase.logging_init("INFO", True)
# Init
self.lastMessage = None
self.onLogCallCount = 0
def setUp(self):
"""
Setup (called before each test)
"""
# Initialize asap
SolBase.voodoo_init()
SolBase.set_compo_name("CompoNotSet")
self.assertTrue(SolBase._voodoo_initialized)
self.assertTrue(SolBase._logging_initialized)
def setUp(self):
"""
Setup (called before each test)
"""
# Initialize asap
SolBase.voodoo_init()
SolBase.set_compo_name("CompoNotSet")
self.assertTrue(SolBase._voodoo_initialized)
self.assertTrue(SolBase._logging_initialized)
# Reset
Meters.reset()
# Bench
self.per_loop = 10000
self.max_ms = 2000
def setUp(self):
"""
Setup
"""
SolBase.voodoo_init()
Utility.gevent_reset()
Utility.test_wait()
# Init
self.tcp_server = None
self.arTcpClient = None
# Config server
self.serverHelloTimeOutMs = 30000
self.serverPingIntervalMs = 10000
self.serverPingTimeOutMs = 60000
# Config client
self.clientHelloTimeOutMs = 30000
self.clientPingIntervalMs = 10000
self.clientPingTimeOutMs = 60000
# Config test
self.runTimeMs = 20000
self.statEveryMs = 10000
self.checkTimeOutMs = 60000
# Client config test
self.clientMaxCount = 5
# Misc
self.expectedPps = 0
# Debug
self.debug_log = False
# Reset
Meters.reset()
# ssl
self.testSsl = False
self.testProxy = False
self.certificatesPath = Utility.generate_server_keys()
def setUp(self):
"""
Setup
"""
SolBase.voodoo_init()
Utility.gevent_reset()
logger.info("setUp : entering")
Utility.test_wait()
# Timeout
self.checkTimeOut = 2500
# Init
self.tcp_server = None
self.tcp_client = None
# Certificate path
self.certificatesPath = Utility.generate_server_keys()
logger.info("Setting certificates_path=%s", self.certificatesPath)
def setUp(self):
"""
Setup
"""
Utility.gevent_reset()
SolBase.voodoo_init()
Utility.test_wait()
# Init
self.tcp_server = None
self.tcpClient = None
# Config server
self.serverHelloTimeOutMs = 10000
self.serverPingIntervalMs = 10000
self.serverPingTimeoutMs = 10000
# Config client
self.clientHelloTimeOutMs = 10000
self.clientPingIntervalMs = 10000
self.clientPingTimeOutMs = 10000
# Config test
self.checkTimeOutMs = 10000
self.checkPingTimeOutMs = 30000
# Client config test
self.clientMaxCount = 10000
self.clientWaitMsBetweenSegment = 5000
self.clientSegment = 100
# Reset
Meters.reset()
# ssl
self.testSsl = False
self.certificatesPath = Utility.generate_server_keys()
def setUp(self):
"""
Setup
"""
logger.info("*** SETUP in")
SolBase.voodoo_init()
self.run_idx = 0
self.current_dir = dirname(
abspath(__file__)) + SolBase.get_pathseparator()
# Reset (teamcity broke the whole stuff)
self.tc_stdin = sys.stdin
self.tc_stdout = sys.stdout
self.tc_stderr = sys.stderr
sys.stdin = real_stdin
sys.stdout = real_stdout
sys.stderr = real_stderr
# Log
logger.info("Entering, %s", SolBase.get_current_pid_as_string())
# Config
self.test_timeout_ms = 30000
self.stdout_timeout_ms = 5000
self.std_err_timeout_ms = 500
self.daemon_pid_file = "/tmp/Daemon.pid"
self.daemon_std_out = "/tmp/Daemon.out.txt"
self.daemon_std_err = "/tmp/Daemon.err.txt"
# Clean
self._clean_files()
logger.info("*** SETUP out")
from socket import error
from threading import Lock
import gevent
from gevent import GreenletExit
# noinspection PyProtectedMember
from gevent._socketcommon import wait_read, wait_write
# noinspection PyProtectedMember
from gevent.queue import Queue, Empty
from pysolbase.SolBase import SolBase
from pysolmeters.Meters import Meters
from pysoltcp import string_types, binary_type
from pysoltcp.tcpbase.SignaledBuffer import SignaledBuffer
SolBase.voodoo_init()
logger = logging.getLogger(__name__)
class TcpSocketManager(object):
"""
Tcp socket manager.
"""
# Send queue : Wait in ms per loop.
# Upon queue fill, called is unlocked immediately.
# We use a call go get(Block=True, QUEUE_WAIT_MS_PER_LOOP) to avoid eating cpu while waiting.
# Value in second OR None for unlimited wait.
QUEUE_WAIT_SEC_PER_LOOP = None
def __init__(self, callback_disconnect, callback_receive):
def _godaemon(self):
"""
daemonize us
"""
logger.debug("Entering, pid=%s", os.getpid())
# Limit
self._set_limits()
# Fork1
logger.debug("fork1, %s", SolBase.get_current_pid_as_string())
try:
pid = gevent.fork()
if pid > 0:
# Exit first parent
logger.debug("exit(0) first parent")
sys.exit(0)
except OSError as ex:
logger.error("fork1 failed, exit(1) now : errno=%s, err=%s, ex=%s",
ex.errno, ex.strerror, SolBase.extostr(ex))
sys.exit(1)
logger.debug("fork1 done, %s", SolBase.get_current_pid_as_string())
# Diverge from parent
if self._changeDir:
logger.debug("chdir now")
os.chdir("/")
# Set stuff
logger.debug("setsid and umask")
# noinspection PyArgumentList
os.setsid()
os.umask(0)
# Fork2
logger.debug("fork2, %s", SolBase.get_current_pid_as_string())
try:
pid = gevent.fork()
if pid > 0:
# exit from second parent
logger.debug("exit(0) second parent")
sys.exit(0)
except OSError as ex:
logger.error("fork2 failed, exit(2) now : errno=%s, err=%s, ex=%s",
ex.errno, ex.strerror, SolBase.extostr(ex))
sys.exit(2)
logger.debug("fork2 done, %s", SolBase.get_current_pid_as_string())
# Redirect std
self._redirect_all_std()
# Go
logger.debug("initializing _pidfile=%s", self._pidfile)
# Register the method called at exit
atexit.register(self._remove_pid_file)
# Write pidfile
pid = str(os.getpid())
try:
f = open(self._pidfile, "w")
f.write("%s" % pid)
f.close()
except IOError as ex:
logger.error(
"pid file initialization failed, going exit(3), ex=%s",
SolBase.extostr(ex))
sys.exit(3)
# Ok
logger.debug("pid file set")
# Finish
logger.debug("registering gevent signal handler : SIGUSR1")
signal(SIGUSR1, self._on_reload)
logger.debug("registering gevent signal handler : SIGUSR2")
signal(SIGUSR2, self._on_status)
logger.debug("registering gevent signal handler : SIGTERM")
signal(SIGTERM, self._exit_handler)
logger.debug("registering gevent signal handler : done")
# Fatality
SolBase.voodoo_init()
logger.debug("process started, pid=%s, pidfile=%s", os.getpid(),
self._pidfile)
def setUp(self):
"""
Setup
"""
SolBase.voodoo_init()
#
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
# ===============================================================================
"""
# WE MUST MONKEY PATCH ASAP HERE FOR PY3
from pysolbase.SolBase import SolBase
SolBase.voodoo_init(init_logging=False)
# noinspection PyPep8
import warnings
warnings.simplefilter("ignore", ResourceWarning)
# noinspection PyPep8
from urllib3.exceptions import InsecureRequestWarning
warnings.simplefilter("ignore", InsecureRequestWarning)
