def __init__(self, core, sequence, phout, answ, answ_level, timeout, section):
self.core = core
self.address_wizard = AddressWizard()
self.sequence_no = sequence
self.log = logging.getLogger(__name__)
self.section = section
self.stepper_wrapper = StepperWrapper(self.core, self.section)
self.phout_file = phout
self.answ_log = answ
self.answ_log_level = answ_level
self.timeout = timeout
# per benchmark
self.instances = None
self.ipv6 = None
self.ssl = None
self.address = None
self.port = None
self.tank_type = None
self.stpd = None
self.gatling = None
self.phantom_http_line = None
self.phantom_http_field_num = None
self.phantom_http_field = None
self.phantom_http_entity = None
self.resolved_ip = None
self.method_prefix = None
self.source_log_prefix = None
self.method_options = None
def __init__(self, core):
self.log = logging.getLogger(__name__)
AbstractPlugin.__init__(self, core)
self.gun_type = None
self.start_time = time.time()
self.stepper_wrapper = StepperWrapper(self.core, BFGPlugin.SECTION)
self.log.info("Initialized BFG")
self.gun_classes = {
'log': LogGun,
'sql': SqlGun,
'custom': CustomGun,
}
def __init__(self, core, sequence, phout, answ, answ_level, timeout, section):
self.core = core
self.sequence_no = sequence
self.log = logging.getLogger(__name__)
self.section = section
self.stepper_wrapper = StepperWrapper(self.core, self.section)
self.phout_file = phout
self.answ_log = answ
self.answ_log_level = answ_level
self.timeout = timeout
# per benchmark
self.instances = None
self.ipv6 = None
self.ssl = None
self.address = None
self.port = None
self.tank_type = None
self.stpd = None
self.gatling = None
self.phantom_http_line = None
self.phantom_http_field_num = None
self.phantom_http_field = None
self.phantom_http_entity = None
self.resolved_ip = None
self.method_prefix = None
self.source_log_prefix = None
self.method_options = None
def get_available_options():
opts = ["ssl", "tank_type", 'gatling_ip',
"method_prefix", "source_log_prefix"]
opts += ["phantom_http_line", "phantom_http_field_num",
"phantom_http_field", "phantom_http_entity"]
opts += ['address', "port", StreamConfig.OPTION_INSTANCES_LIMIT]
opts += StepperWrapper.get_available_options()
return opts
def get_available_options():
opts = ["ssl", "tank_type", 'gatling_ip',
"method_prefix", "source_log_prefix"]
opts += ["phantom_http_line", "phantom_http_field_num",
"phantom_http_field", "phantom_http_entity"]
opts += ['address', "port", StreamConfig.OPTION_INSTANCES_LIMIT]
opts += StepperWrapper.get_available_options()
return opts
def __init__(self, core):
self.log = logging.getLogger(__name__)
AbstractPlugin.__init__(self, core)
self.gun_type = None
self.start_time = time.time()
self.stepper_wrapper = StepperWrapper(self.core, BFGPlugin.SECTION)
self.log.info("Initialized BFG")
self.gun_classes = {
'log': LogGun,
'sql': SqlGun,
'custom': CustomGun,
}
class BFGPlugin(AbstractPlugin):
''' Big F*****g Gun plugin '''
SECTION = 'bfg'
def __init__(self, core):
self.log = logging.getLogger(__name__)
AbstractPlugin.__init__(self, core)
self.gun_type = None
self.start_time = time.time()
self.stepper_wrapper = StepperWrapper(self.core, BFGPlugin.SECTION)
self.log.info("Initialized BFG")
self.gun_classes = {
'log': LogGun,
'sql': SqlGun,
'custom': CustomGun,
}
@staticmethod
def get_key():
return __file__
def get_available_options(self):
return ["gun_type", "instances", "cached_stpd"] + self.stepper_wrapper.get_available_options
def configure(self):
self.log.info("Configuring BFG...")
self.stepper_wrapper.read_config()
def prepare_test(self):
self.stepper_wrapper.prepare_stepper()
gun_type = self.get_option("gun_type")
if gun_type in self.gun_classes:
self.gun = self.gun_classes[gun_type](self.core)
else:
raise NotImplementedError(
'No such gun type implemented: "%s"' % gun_type)
cached_stpd_option = self.get_option("cached_stpd", '0')
if cached_stpd_option == '1':
cached_stpd = True
else:
cached_stpd = False
self.bfg = BFG(
gun=self.gun,
instances=self.get_option("instances", '15'),
threads=self.get_option("threads", '10'),
stpd_filename=self.stepper_wrapper.stpd,
cached_stpd=cached_stpd,
)
aggregator = None
try:
aggregator = self.core.get_plugin_of_type(AggregatorPlugin)
except Exception, ex:
self.log.warning("No aggregator found: %s", ex)
if aggregator:
result_cache_size = int(self.get_option("result_cache_size", '5'))
aggregator.reader = BFGReader(
aggregator, self.bfg, result_cache_size=result_cache_size)
try:
console = self.core.get_plugin_of_type(ConsoleOnlinePlugin)
except Exception, ex:
self.log.debug("Console not found: %s", ex)
console = None
class StreamConfig:
""" each test stream's config """
OPTION_INSTANCES_LIMIT = 'instances'
def __init__(self, core, sequence, phout, answ, answ_level, timeout, section):
self.core = core
self.address_wizard = AddressWizard()
self.sequence_no = sequence
self.log = logging.getLogger(__name__)
self.section = section
self.stepper_wrapper = StepperWrapper(self.core, self.section)
self.phout_file = phout
self.answ_log = answ
self.answ_log_level = answ_level
self.timeout = timeout
# per benchmark
self.instances = None
self.ipv6 = None
self.ssl = None
self.address = None
self.port = None
self.tank_type = None
self.stpd = None
self.gatling = None
self.phantom_http_line = None
self.phantom_http_field_num = None
self.phantom_http_field = None
self.phantom_http_entity = None
self.resolved_ip = None
self.method_prefix = None
self.source_log_prefix = None
self.method_options = None
def get_option(self, option_ammofile, default=None):
""" get option wrapper """
return self.core.get_option(self.section, option_ammofile, default)
@staticmethod
def get_available_options():
opts = ["ssl", "tank_type", 'gatling_ip',
"method_prefix", "source_log_prefix"]
opts += ["phantom_http_line", "phantom_http_field_num",
"phantom_http_field", "phantom_http_entity"]
opts += ['address', "port", StreamConfig.OPTION_INSTANCES_LIMIT]
opts += StepperWrapper.get_available_options()
opts += ["connection_test"]
return opts
def read_config(self):
""" reads config """
# multi-options
self.ssl = int(self.get_option("ssl", '0'))
self.tank_type = self.get_option("tank_type", 'http')
# TODO: refactor. Maybe we should decide how to interact with StepperWrapper here.
self.instances = int(
self.get_option(self.OPTION_INSTANCES_LIMIT, '1000'))
self.gatling = ' '.join(self.get_option('gatling_ip', '').split("\n"))
self.method_prefix = self.get_option("method_prefix", 'method_stream')
self.method_options = self.get_option("method_options", '')
self.source_log_prefix = self.get_option("source_log_prefix", '')
self.phantom_http_line = self.get_option("phantom_http_line", "")
self.phantom_http_field_num = self.get_option("phantom_http_field_num", "")
self.phantom_http_field = self.get_option("phantom_http_field", "")
self.phantom_http_entity = self.get_option("phantom_http_entity", "")
self.address = self.get_option('address', '127.0.0.1')
self.ipv6, self.resolved_ip, self.port, self.address = self.address_wizard.resolve(self.address)
if self.port is None:
explicit_port = self.get_option('port', '')
if explicit_port:
self.log.warn("Using phantom.port option is deprecated. Use phantom.address=[address]:port instead")
self.port = int(explicit_port)
else:
self.port = 80
logging.info("Resolved %s into %s:%s", self.address, self.resolved_ip, self.port)
if int(self.get_option("connection_test", "1")):
self.address_wizard.test(self.resolved_ip, self.port)
self.stepper_wrapper.read_config()
def compose_config(self):
""" compose benchmark block """
# step file
self.stepper_wrapper.prepare_stepper()
self.stpd = self.stepper_wrapper.stpd
if self.stepper_wrapper.instances:
self.instances = self.stepper_wrapper.instances
if not self.stpd:
raise RuntimeError("Cannot proceed with no STPD file")
kwargs = {}
kwargs['sequence_no'] = self.sequence_no
kwargs[
'ssl_transport'] = "transport_t ssl_transport = transport_ssl_t { timeout = 1s }\n transport = ssl_transport" if self.ssl else ""
kwargs['method_stream'] = self.method_prefix + \
"_ipv6_t" if self.ipv6 else self.method_prefix + "_ipv4_t"
kwargs['phout'] = self.phout_file
kwargs['answ_log'] = self.answ_log
kwargs['answ_log_level'] = self.answ_log_level
kwargs['comment_answ'] = "# " if self.answ_log_level == 'none' else ''
kwargs['stpd'] = self.stpd
kwargs['source_log_prefix'] = self.source_log_prefix
kwargs['method_options'] = self.method_options
if self.tank_type:
kwargs[
'proto'] = "proto=http_proto%s" % self.sequence_no if self.tank_type == 'http' else "proto=none_proto"
kwargs['comment_proto'] = ""
else:
kwargs['proto'] = ""
kwargs['comment_proto'] = "#"
if self.gatling:
kwargs['bind'] = 'bind={ ' + self.gatling + ' }'
else:
kwargs['bind'] = ''
kwargs['ip'] = self.resolved_ip
kwargs['port'] = self.port
kwargs['timeout'] = self.timeout
kwargs['instances'] = self.instances
tune = ''
if self.phantom_http_entity:
tune += "entity = " + self.phantom_http_entity + "\n"
if self.phantom_http_field:
tune += "field = " + self.phantom_http_field + "\n"
if self.phantom_http_field_num:
tune += "field_num = " + self.phantom_http_field_num + "\n"
if self.phantom_http_line:
tune += "line = " + self.phantom_http_line + "\n"
if tune:
kwargs['reply_limits'] = 'reply_limits = {\n' + tune + "}"
else:
kwargs['reply_limits'] = ''
if self.section == PhantomConfig.SECTION:
fname = 'phantom_benchmark_main.tpl'
else:
fname = 'phantom_benchmark_additional.tpl'
tplf = open(os.path.dirname(__file__) + '/phantom/' + fname, 'r')
template_str = tplf.read()
tplf.close()
tpl = string.Template(template_str)
config = tpl.substitute(kwargs)
return config
class StreamConfig:
''' each test stream's config '''
OPTION_INSTANCES_LIMIT = 'instances'
def __init__(self, core, sequence, phout, answ, answ_level, timeout, section):
self.core = core
self.sequence_no = sequence
self.log = logging.getLogger(__name__)
self.section = section
self.stepper_wrapper = StepperWrapper(self.core, self.section)
self.phout_file = phout
self.answ_log = answ
self.answ_log_level = answ_level
self.timeout = timeout
# per benchmark
self.instances = None
self.ipv6 = None
self.ssl = None
self.address = None
self.port = None
self.tank_type = None
self.stpd = None
self.gatling = None
self.phantom_http_line = None
self.phantom_http_field_num = None
self.phantom_http_field = None
self.phantom_http_entity = None
self.resolved_ip = None
self.method_prefix = None
self.source_log_prefix = None
self.method_options = None
def get_option(self, option_ammofile, default=None):
''' get option wrapper '''
return self.core.get_option(self.section, option_ammofile, default)
@staticmethod
def get_available_options():
opts = ["ssl", "tank_type", 'gatling_ip',
"method_prefix", "source_log_prefix"]
opts += ["phantom_http_line", "phantom_http_field_num",
"phantom_http_field", "phantom_http_entity"]
opts += ['address', "port", StreamConfig.OPTION_INSTANCES_LIMIT]
opts += StepperWrapper.get_available_options()
return opts
def read_config(self):
''' reads config '''
# multi-options
self.ssl = int(self.get_option("ssl", '0'))
self.tank_type = self.get_option("tank_type", 'http')
# TODO: refactor. Maybe we should decide how to interact with StepperWrapper here.
self.instances = int(
self.get_option(self.OPTION_INSTANCES_LIMIT, '1000'))
self.gatling = ' '.join(self.get_option('gatling_ip', '').split("\n"))
self.method_prefix = self.get_option("method_prefix", 'method_stream')
self.method_options = self.get_option("method_options", '')
self.source_log_prefix = self.get_option("source_log_prefix", '')
self.phantom_http_line = self.get_option("phantom_http_line", "")
self.phantom_http_field_num = self.get_option(
"phantom_http_field_num", "")
self.phantom_http_field = self.get_option("phantom_http_field", "")
self.phantom_http_entity = self.get_option("phantom_http_entity", "")
self.address = self.get_option('address', 'localhost')
self.port = self.get_option('port', '80')
self.__resolve_address()
self.stepper_wrapper.read_config()
def compose_config(self):
''' compose benchmark block '''
# step file
self.stepper_wrapper.prepare_stepper()
self.stpd = self.stepper_wrapper.stpd
if self.stepper_wrapper.instances:
self.instances = self.stepper_wrapper.instances
if not self.stpd:
raise RuntimeError("Cannot proceed with no STPD file")
kwargs = {}
kwargs['sequence_no'] = self.sequence_no
kwargs[
'ssl_transport'] = "transport_t ssl_transport = transport_ssl_t { timeout = 1s }\n transport = ssl_transport" if self.ssl else ""
kwargs['method_stream'] = self.method_prefix + \
"_ipv6_t" if self.ipv6 else self.method_prefix + "_ipv4_t"
kwargs['phout'] = self.phout_file
kwargs['answ_log'] = self.answ_log
kwargs['answ_log_level'] = self.answ_log_level
kwargs['comment_answ'] = "# " if self.answ_log_level == 'none' else ''
kwargs['stpd'] = self.stpd
kwargs['source_log_prefix'] = self.source_log_prefix
kwargs['method_options'] = self.method_options
if self.tank_type:
kwargs[
'proto'] = "proto=http_proto%s" % self.sequence_no if self.tank_type == 'http' else "proto=none_proto"
kwargs['comment_proto'] = ""
else:
kwargs['proto'] = ""
kwargs['comment_proto'] = "#"
if self.gatling:
kwargs['bind'] = 'bind={ ' + self.gatling + ' }'
else:
kwargs['bind'] = ''
kwargs['ip'] = self.resolved_ip
kwargs['port'] = self.port
kwargs['timeout'] = self.timeout
kwargs['instances'] = self.instances
tune = ''
if self.phantom_http_entity:
tune += "entity = " + self.phantom_http_entity + "\n"
if self.phantom_http_field:
tune += "field = " + self.phantom_http_field + "\n"
if self.phantom_http_field_num:
tune += "field_num = " + self.phantom_http_field_num + "\n"
if self.phantom_http_line:
tune += "line = " + self.phantom_http_line + "\n"
if tune:
kwargs['reply_limits'] = 'reply_limits = {\n' + tune + "}"
else:
kwargs['reply_limits'] = ''
if self.section == PhantomConfig.SECTION:
fname = 'phantom_benchmark_main.tpl'
else:
fname = 'phantom_benchmark_additional.tpl'
tplf = open(os.path.dirname(__file__) + '/' + fname, 'r')
template_str = tplf.read()
tplf.close()
tpl = string.Template(template_str)
config = tpl.substitute(kwargs)
return config
# FIXME: this method became a piece of shit, needs refactoring
def __resolve_address(self):
''' Analyse target address setting, resolve it to IP '''
if not self.address:
raise RuntimeError("Target address not specified")
try:
ipaddr.IPv6Address(self.address)
self.ipv6 = True
self.resolved_ip = self.address
try:
self.address = socket.gethostbyaddr(self.resolved_ip)[0]
except Exception, exc:
self.log.debug("Failed to get hostname for ip: %s", exc)
self.address = self.resolved_ip
except AddressValueError:
self.log.debug("Not ipv6 address: %s", self.address)
self.ipv6 = False
address_port = self.address.split(":")
self.address = address_port[0]
if len(address_port) > 1:
self.port = address_port[1]
try:
ipaddr.IPv4Address(self.address)
self.resolved_ip = self.address
try:
self.address = socket.gethostbyaddr(self.resolved_ip)[0]
except Exception, exc:
self.log.debug("Failed to get hostname for ip: %s", exc)
self.address = self.resolved_ip
except AddressValueError:
self.log.debug("Not ipv4 address: %s", self.address)
# TODO: use getaddrinfo to support IPv6
ip_addr = socket.gethostbyname(self.address)
reverse_name = socket.gethostbyaddr(ip_addr)[0]
self.log.debug(
"Address %s ip_addr: %s, reverse-resolve: %s", self.address, ip_addr, reverse_name)
if reverse_name.startswith(self.address):
self.resolved_ip = ip_addr
else:
raise ValueError(
"Address %s reverse-resolved to %s, but must match" % (self.address, reverse_name))
class StreamConfig:
""" each test stream's config """
OPTION_INSTANCES_LIMIT = 'instances'
def __init__(self, core, sequence, phout, answ, answ_level, timeout, section):
self.core = core
self.address_wizard = AddressWizard()
self.sequence_no = sequence
self.log = logging.getLogger(__name__)
self.section = section
self.stepper_wrapper = StepperWrapper(self.core, self.section)
self.phout_file = phout
self.answ_log = answ
self.answ_log_level = answ_level
self.timeout = timeout
# per benchmark
self.instances = None
self.ipv6 = None
self.ssl = None
self.address = None
self.port = None
self.tank_type = None
self.stpd = None
self.gatling = None
self.phantom_http_line = None
self.phantom_http_field_num = None
self.phantom_http_field = None
self.phantom_http_entity = None
self.resolved_ip = None
self.method_prefix = None
self.source_log_prefix = None
self.method_options = None
def get_option(self, option_ammofile, default=None):
""" get option wrapper """
return self.core.get_option(self.section, option_ammofile, default)
@staticmethod
def get_available_options():
opts = ["ssl", "tank_type", 'gatling_ip',
"method_prefix", "source_log_prefix"]
opts += ["phantom_http_line", "phantom_http_field_num",
"phantom_http_field", "phantom_http_entity"]
opts += ['address', "port", StreamConfig.OPTION_INSTANCES_LIMIT]
opts += StepperWrapper.get_available_options()
opts += ["connection_test"]
return opts
def read_config(self):
""" reads config """
# multi-options
self.ssl = int(self.get_option("ssl", '0'))
self.tank_type = self.get_option("tank_type", 'http')
# TODO: refactor. Maybe we should decide how to interact with StepperWrapper here.
self.instances = int(
self.get_option(self.OPTION_INSTANCES_LIMIT, '1000'))
self.gatling = ' '.join(self.get_option('gatling_ip', '').split("\n"))
self.method_prefix = self.get_option("method_prefix", 'method_stream')
self.method_options = self.get_option("method_options", '')
self.source_log_prefix = self.get_option("source_log_prefix", '')
self.phantom_http_line = self.get_option("phantom_http_line", "")
self.phantom_http_field_num = self.get_option("phantom_http_field_num", "")
self.phantom_http_field = self.get_option("phantom_http_field", "")
self.phantom_http_entity = self.get_option("phantom_http_entity", "")
self.address = self.get_option('address', '127.0.0.1')
do_test_connect = int(self.get_option("connection_test", "1")) > 0
explicit_port = self.get_option('port', '')
self.ipv6, self.resolved_ip, self.port, self.address = self.address_wizard.resolve(self.address,
do_test_connect,
explicit_port)
logging.info("Resolved %s into %s:%s", self.address, self.resolved_ip, self.port)
self.stepper_wrapper.read_config()
def compose_config(self):
""" compose benchmark block """
# step file
self.stepper_wrapper.prepare_stepper()
self.stpd = self.stepper_wrapper.stpd
if self.stepper_wrapper.instances:
self.instances = self.stepper_wrapper.instances
if not self.stpd:
raise RuntimeError("Cannot proceed with no STPD file")
kwargs = {}
kwargs['sequence_no'] = self.sequence_no
kwargs[
'ssl_transport'] = "transport_t ssl_transport = transport_ssl_t { timeout = 1s }\n transport = ssl_transport" if self.ssl else ""
kwargs['method_stream'] = self.method_prefix + \
"_ipv6_t" if self.ipv6 else self.method_prefix + "_ipv4_t"
kwargs['phout'] = self.phout_file
kwargs['answ_log'] = self.answ_log
kwargs['answ_log_level'] = self.answ_log_level
kwargs['comment_answ'] = "# " if self.answ_log_level == 'none' else ''
kwargs['stpd'] = self.stpd
kwargs['source_log_prefix'] = self.source_log_prefix
kwargs['method_options'] = self.method_options
if self.tank_type:
kwargs[
'proto'] = "proto=http_proto%s" % self.sequence_no if self.tank_type == 'http' else "proto=none_proto"
kwargs['comment_proto'] = ""
else:
kwargs['proto'] = ""
kwargs['comment_proto'] = "#"
if self.gatling:
kwargs['bind'] = 'bind={ ' + self.gatling + ' }'
else:
kwargs['bind'] = ''
kwargs['ip'] = self.resolved_ip
kwargs['port'] = self.port
kwargs['timeout'] = self.timeout
kwargs['instances'] = self.instances
tune = ''
if self.phantom_http_entity:
tune += "entity = " + self.phantom_http_entity + "\n"
if self.phantom_http_field:
tune += "field = " + self.phantom_http_field + "\n"
if self.phantom_http_field_num:
tune += "field_num = " + self.phantom_http_field_num + "\n"
if self.phantom_http_line:
tune += "line = " + self.phantom_http_line + "\n"
if tune:
kwargs['reply_limits'] = 'reply_limits = {\n' + tune + "}"
else:
kwargs['reply_limits'] = ''
if self.section == PhantomConfig.SECTION:
fname = 'phantom_benchmark_main.tpl'
else:
fname = 'phantom_benchmark_additional.tpl'
tplf = open(os.path.dirname(__file__) + '/phantom/' + fname, 'r')
template_str = tplf.read()
tplf.close()
tpl = string.Template(template_str)
config = tpl.substitute(kwargs)
return config
class BFGPlugin(AbstractPlugin):
''' Big F*****g Gun plugin '''
SECTION = 'bfg'
def __init__(self, core):
self.log = logging.getLogger(__name__)
AbstractPlugin.__init__(self, core)
self.gun_type = None
self.start_time = time.time()
self.stepper_wrapper = StepperWrapper(self.core, BFGPlugin.SECTION)
self.log.info("Initialized BFG")
self.gun_classes = {
'log': LogGun,
'sql': SqlGun,
'custom': CustomGun,
'http': HttpGun,
}
@staticmethod
def get_key():
return __file__
def get_available_options(self):
return ["gun_type", "instances", "cached_stpd"
] + self.stepper_wrapper.get_available_options
def configure(self):
self.log.info("Configuring BFG...")
self.stepper_wrapper.read_config()
def prepare_test(self):
self.log.info(self.get_option("ammo_type"))
self.stepper_wrapper.prepare_stepper()
gun_type = self.get_option("gun_type")
if gun_type in self.gun_classes:
self.gun = self.gun_classes[gun_type](self.core)
else:
raise NotImplementedError('No such gun type implemented: "%s"' %
gun_type)
cached_stpd_option = self.get_option("cached_stpd", '0')
if cached_stpd_option == '1':
cached_stpd = True
else:
cached_stpd = False
self.bfg = BFG(gun=self.gun,
instances=self.get_option("instances", '15'),
threads=self.get_option("threads", '10'),
stpd_filename=self.stepper_wrapper.stpd,
cached_stpd=cached_stpd,
zmq=self.get_option("zmq", None))
aggregator = None
try:
aggregator = self.core.get_plugin_of_type(AggregatorPlugin)
except Exception, ex:
self.log.warning("No aggregator found: %s", ex)
if aggregator:
result_cache_size = int(self.get_option("result_cache_size", '5'))
aggregator.reader = BFGReader(aggregator,
self.bfg,
result_cache_size=result_cache_size)
try:
console = self.core.get_plugin_of_type(ConsoleOnlinePlugin)
except Exception, ex:
self.log.debug("Console not found: %s", ex)
console = None
class StreamConfig:
''' each test stream's config '''
OPTION_INSTANCES_LIMIT = 'instances'
def __init__(self, core, sequence, phout, answ, answ_level, timeout, section):
self.core = core
self.sequence_no = sequence
self.log = logging.getLogger(__name__)
self.section = section
self.stepper_wrapper = StepperWrapper(self.core, self.section)
self.phout_file = phout
self.answ_log = answ
self.answ_log_level = answ_level
self.timeout = timeout
# per benchmark
self.instances = None
self.ipv6 = None
self.ssl = None
self.address = None
self.port = None
self.tank_type = None
self.stpd = None
self.gatling = None
self.phantom_http_line = None
self.phantom_http_field_num = None
self.phantom_http_field = None
self.phantom_http_entity = None
self.resolved_ip = None
self.method_prefix = None
self.source_log_prefix = None
self.method_options = None
def get_option(self, option_ammofile, default=None):
''' get option wrapper '''
return self.core.get_option(self.section, option_ammofile, default)
@staticmethod
def get_available_options():
opts = ["ssl", "tank_type", 'gatling_ip',
"method_prefix", "source_log_prefix"]
opts += ["phantom_http_line", "phantom_http_field_num",
"phantom_http_field", "phantom_http_entity"]
opts += ['address', "port", StreamConfig.OPTION_INSTANCES_LIMIT]
opts += StepperWrapper.get_available_options()
return opts
def read_config(self):
''' reads config '''
# multi-options
self.ssl = int(self.get_option("ssl", '0'))
self.tank_type = self.get_option("tank_type", 'http')
# TODO: refactor. Maybe we should decide how to interact with StepperWrapper here.
self.instances = int(
self.get_option(self.OPTION_INSTANCES_LIMIT, '1000'))
self.gatling = ' '.join(self.get_option('gatling_ip', '').split("\n"))
self.method_prefix = self.get_option("method_prefix", 'method_stream')
self.method_options = self.get_option("method_options", '')
self.source_log_prefix = self.get_option("source_log_prefix", '')
self.phantom_http_line = self.get_option("phantom_http_line", "")
self.phantom_http_field_num = self.get_option(
"phantom_http_field_num", "")
self.phantom_http_field = self.get_option("phantom_http_field", "")
self.phantom_http_entity = self.get_option("phantom_http_entity", "")
self.address = self.get_option('address', 'localhost')
self.port = self.get_option('port', '80')
self.__resolve_address()
self.stepper_wrapper.read_config()
def compose_config(self):
''' compose benchmark block '''
# step file
self.stepper_wrapper.prepare_stepper()
self.stpd = self.stepper_wrapper.stpd
if self.stepper_wrapper.instances:
self.instances = self.stepper_wrapper.instances
if not self.stpd:
raise RuntimeError("Cannot proceed with no STPD file")
kwargs = {}
kwargs['sequence_no'] = self.sequence_no
kwargs[
'ssl_transport'] = "transport_t ssl_transport = transport_ssl_t { timeout = 1s }\n transport = ssl_transport" if self.ssl else ""
kwargs['method_stream'] = self.method_prefix + \
"_ipv6_t" if self.ipv6 else self.method_prefix + "_ipv4_t"
kwargs['phout'] = self.phout_file
kwargs['answ_log'] = self.answ_log
kwargs['answ_log_level'] = self.answ_log_level
kwargs['comment_answ'] = "# " if self.answ_log_level == 'none' else ''
kwargs['stpd'] = self.stpd
kwargs['source_log_prefix'] = self.source_log_prefix
kwargs['method_options'] = self.method_options
if self.tank_type:
kwargs[
'proto'] = "proto=http_proto%s" % self.sequence_no if self.tank_type == 'http' else "proto=none_proto"
kwargs['comment_proto'] = ""
else:
kwargs['proto'] = ""
kwargs['comment_proto'] = "#"
if self.gatling:
kwargs['bind'] = 'bind={ ' + self.gatling + ' }'
else:
kwargs['bind'] = ''
kwargs['ip'] = self.resolved_ip
kwargs['port'] = self.port
kwargs['timeout'] = self.timeout
kwargs['instances'] = self.instances
tune = ''
if self.phantom_http_entity:
tune += "entity = " + self.phantom_http_entity + "\n"
if self.phantom_http_field:
tune += "field = " + self.phantom_http_field + "\n"
if self.phantom_http_field_num:
tune += "field_num = " + self.phantom_http_field_num + "\n"
if self.phantom_http_line:
tune += "line = " + self.phantom_http_line + "\n"
if tune:
kwargs['reply_limits'] = 'reply_limits = {\n' + tune + "}"
else:
kwargs['reply_limits'] = ''
if self.section == PhantomConfig.SECTION:
fname = 'phantom_benchmark_main.tpl'
else:
fname = 'phantom_benchmark_additional.tpl'
tplf = open(os.path.dirname(__file__) + '/' + fname, 'r')
template_str = tplf.read()
tplf.close()
tpl = string.Template(template_str)
config = tpl.substitute(kwargs)
return config
# FIXME: this method became a piece of shit, needs refactoring
def __resolve_address(self):
''' Analyse target address setting, resolve it to IP '''
if not self.address:
raise RuntimeError("Target address not specified")
try:
ipaddr.IPv6Address(self.address)
self.ipv6 = True
self.resolved_ip = self.address
try:
self.address = socket.gethostbyaddr(self.resolved_ip)[0]
except Exception, exc:
self.log.debug("Failed to get hostname for ip: %s", exc)
self.address = self.resolved_ip
except AddressValueError:
self.log.debug("Not ipv6 address: %s", self.address)
self.ipv6 = False
address_port = self.address.split(":")
self.address = address_port[0]
if len(address_port) > 1:
self.port = address_port[1]
try:
ipaddr.IPv4Address(self.address)
self.resolved_ip = self.address
try:
self.address = socket.gethostbyaddr(self.resolved_ip)[0]
except Exception, exc:
self.log.debug("Failed to get hostname for ip: %s", exc)
self.address = self.resolved_ip
except AddressValueError:
self.log.debug("Not ipv4 address: %s", self.address)
# TODO: use getaddrinfo to support IPv6
ip_addr = socket.gethostbyname(self.address)
reverse_name = socket.gethostbyaddr(ip_addr)[0]
self.log.debug(
"Address %s ip_addr: %s, reverse-resolve: %s", self.address, ip_addr, reverse_name)
if reverse_name.startswith(self.address):
self.resolved_ip = ip_addr
else:
raise ValueError(
"Address %s reverse-resolved to %s, but must match" % (self.address, reverse_name))
class StreamConfig:
''' each test stream's config '''
OPTION_INSTANCES_LIMIT = 'instances'
def __init__(self, core, sequence, phout, answ, answ_level, timeout, section):
self.core = core
self.sequence_no = sequence
self.log = logging.getLogger(__name__)
self.section = section
self.stepper_wrapper = StepperWrapper(self.core, self.section)
self.phout_file = phout
self.answ_log = answ
self.answ_log_level = answ_level
self.timeout = timeout
# per benchmark
self.instances = None
self.ipv6 = None
self.ssl = None
self.address = None
self.port = None
self.tank_type = None
self.stpd = None
self.gatling = None
self.phantom_http_line = None
self.phantom_http_field_num = None
self.phantom_http_field = None
self.phantom_http_entity = None
self.resolved_ip = None
self.method_prefix = None
self.source_log_prefix = None
self.method_options = None
def get_option(self, option_ammofile, default=None):
''' get option wrapper '''
return self.core.get_option(self.section, option_ammofile, default)
@staticmethod
def get_available_options():
opts = ["ssl", "tank_type", 'gatling_ip',
"method_prefix", "source_log_prefix"]
opts += ["phantom_http_line", "phantom_http_field_num",
"phantom_http_field", "phantom_http_entity"]
opts += ['address', "port", StreamConfig.OPTION_INSTANCES_LIMIT]
opts += StepperWrapper.get_available_options()
return opts
def read_config(self):
''' reads config '''
# multi-options
self.ssl = int(self.get_option("ssl", '0'))
self.tank_type = self.get_option("tank_type", 'http')
# TODO: refactor. Maybe we should decide how to interact with StepperWrapper here.
self.instances = int(
self.get_option(self.OPTION_INSTANCES_LIMIT, '1000'))
self.gatling = ' '.join(self.get_option('gatling_ip', '').split("\n"))
self.method_prefix = self.get_option("method_prefix", 'method_stream')
self.method_options = self.get_option("method_options", '')
self.source_log_prefix = self.get_option("source_log_prefix", '')
self.phantom_http_line = self.get_option("phantom_http_line", "")
self.phantom_http_field_num = self.get_option(
"phantom_http_field_num", "")
self.phantom_http_field = self.get_option("phantom_http_field", "")
self.phantom_http_entity = self.get_option("phantom_http_entity", "")
self.address = self.get_option('address', 'localhost')
self.port = self.get_option('port', '80')
#address check section
self.ip_resolved_check = False
if not self.ip_resolved_check:
self.__address_ipv4_check()
if not self.ip_resolved_check:
self.__address_ipv6_check()
if not self.ip_resolved_check:
self.__resolve_address()
if not self.ip_resolved_check:
raise RuntimeError(
"Check what you entered as an address in config. If there is a hostname, check what you get due to DNS lookup",
self.address)
self.stepper_wrapper.read_config()
def compose_config(self):
''' compose benchmark block '''
# step file
self.stepper_wrapper.prepare_stepper()
self.stpd = self.stepper_wrapper.stpd
if self.stepper_wrapper.instances:
self.instances = self.stepper_wrapper.instances
if not self.stpd:
raise RuntimeError("Cannot proceed with no STPD file")
kwargs = {}
kwargs['sequence_no'] = self.sequence_no
kwargs[
'ssl_transport'] = "transport_t ssl_transport = transport_ssl_t { timeout = 1s }\n transport = ssl_transport" if self.ssl else ""
kwargs['method_stream'] = self.method_prefix + \
"_ipv6_t" if self.ipv6 else self.method_prefix + "_ipv4_t"
kwargs['phout'] = self.phout_file
kwargs['answ_log'] = self.answ_log
kwargs['answ_log_level'] = self.answ_log_level
kwargs['comment_answ'] = "# " if self.answ_log_level == 'none' else ''
kwargs['stpd'] = self.stpd
kwargs['source_log_prefix'] = self.source_log_prefix
kwargs['method_options'] = self.method_options
if self.tank_type:
kwargs[
'proto'] = "proto=http_proto%s" % self.sequence_no if self.tank_type == 'http' else "proto=none_proto"
kwargs['comment_proto'] = ""
else:
kwargs['proto'] = ""
kwargs['comment_proto'] = "#"
if self.gatling:
kwargs['bind'] = 'bind={ ' + self.gatling + ' }'
else:
kwargs['bind'] = ''
kwargs['ip'] = self.resolved_ip
kwargs['port'] = self.port
kwargs['timeout'] = self.timeout
kwargs['instances'] = self.instances
tune = ''
if self.phantom_http_entity:
tune += "entity = " + self.phantom_http_entity + "\n"
if self.phantom_http_field:
tune += "field = " + self.phantom_http_field + "\n"
if self.phantom_http_field_num:
tune += "field_num = " + self.phantom_http_field_num + "\n"
if self.phantom_http_line:
tune += "line = " + self.phantom_http_line + "\n"
if tune:
kwargs['reply_limits'] = 'reply_limits = {\n' + tune + "}"
else:
kwargs['reply_limits'] = ''
if self.section == PhantomConfig.SECTION:
fname = 'phantom_benchmark_main.tpl'
else:
fname = 'phantom_benchmark_additional.tpl'
tplf = open(os.path.dirname(__file__) + '/phantom/' + fname, 'r')
template_str = tplf.read()
tplf.close()
tpl = string.Template(template_str)
config = tpl.substitute(kwargs)
return config
def __address_ipv4_check(self):
''' Analyse target address, IPv4 '''
self.ip_resolved_check = False
if not self.address:
raise RuntimeError("Target address not specified")
#IPv4 check
try:
address_final = ipaddr.IPv4Address(self.address)
except AddressValueError:
self.log.debug(
"%s is not IPv4 address", self.address)
else:
self.ipv6 = False
self.ip_resolved_check = True
self.resolved_ip = address_final
self.log.debug(
"%s is IPv4 address", self.address)
#IPv4:port check
try:
address_port = self.address.split(":")
address_final = ipaddr.IPv4Address(address_port[0])
if len(address_port) > 1:
self.port = address_port[1]
except AddressValueError:
self.log.debug(
"%s is not IPv4 address:port", self.address)
else:
self.ipv6 = False
self.ip_resolved_check = True
self.resolved_ip = address_final
self.log.debug(
"%s is IPv4 address and %s is port", address_final, self.port)
def __address_ipv6_check(self):
''' Analyse target address, IPv6 '''
self.ip_resolved_check = False
if not self.address:
raise RuntimeError("Target address not specified")
try:
address_final = ipaddr.IPv6Address(self.address)
except AddressValueError:
self.log.debug(
"%s is not IPv6 address", self.address)
else:
self.ipv6 = True
self.ip_resolved_check = True
self.resolved_ip = address_final
self.log.debug(
"%s is IPv6 address", address_final)
def __resolve_address(self):
''' Resolve hostname to IPv4/IPv6 and analyse what has been resolved '''
self.ip_resolved_check = False
if not self.address:
raise RuntimeError("Target address not specified")
#hostname to ip address lookup
try:
address_port = self.address.split(":")
ip_addr_list_of_tuples = socket.getaddrinfo(address_port[0], None, socket.AF_UNSPEC)[0]
ip_addr_tuple = list(ip_addr_list_of_tuples[4])
address_final = ip_addr_tuple[0]
if len(address_port) > 1:
self.port = address_port[1]
self.log.debug(
"%s resolved to IP address: %s", address_port[0], address_final)
#check if resolved IP is IPv4 or IPv6
try:
ipaddr.IPv4Address(address_final)
except AddressValueError:
self.log.debug(
"Resolved address %s is not IPv4", address_final)
else:
self.ipv6 = False
self.ip_resolved_check = True
self.resolved_ip = address_final
self.log.debug(
"Resolved address %s is IPv4", address_final)
try:
ipaddr.IPv6Address(address_final)
except AddressValueError:
self.log.debug(
"Resolved address %s is not IPv6", address_final)
else:
self.ipv6 = True
self.ip_resolved_check = True
self.resolved_ip = address_final
self.log.debug(
"Resolved address %s is IPv6", address_final)
except socket.error:
raise RuntimeError(
"Unable to resolve hostname", self.address)
