salt/tests/perf/fire_fake.py
Erik Johnson 3184168365 Use explicit unicode strings + break up salt.utils
This PR is part of what will be an ongoing effort to use explicit
unicode strings in Salt. Because Python 3 does not suport Python 2's raw
unicode string syntax (i.e. `ur'\d+'`), we must use
`salt.utils.locales.sdecode()` to ensure that the raw string is unicode.
However, because of how `salt/utils/__init__.py` has evolved into the
hulking monstrosity it is today, this means importing a large module in
places where it is not needed, which could negatively impact
performance. For this reason, this PR also breaks out some of the
functions from `salt/utils/__init__.py` into new/existing modules under
`salt/utils/`. The long term goal will be that the modules within this
directory do not depend on importing `salt.utils`.

A summary of the changes in this PR is as follows:

* Moves the following functions from `salt.utils` to new locations
  (including a deprecation warning if invoked from `salt.utils`):
  `to_bytes`, `to_str`, `to_unicode`, `str_to_num`, `is_quoted`,
  `dequote`, `is_hex`, `is_bin_str`, `rand_string`,
  `contains_whitespace`, `clean_kwargs`, `invalid_kwargs`, `which`,
  `which_bin`, `path_join`, `shlex_split`, `rand_str`, `is_windows`,
  `is_proxy`, `is_linux`, `is_darwin`, `is_sunos`, `is_smartos`,
  `is_smartos_globalzone`, `is_smartos_zone`, `is_freebsd`, `is_netbsd`,
  `is_openbsd`, `is_aix`
* Moves the functions already deprecated by @rallytime to the bottom of
  `salt/utils/__init__.py` for better organization, so we can keep the
  deprecated ones separate from the ones yet to be deprecated as we
  continue to break up `salt.utils`
* Updates `salt/*.py` and all files under `salt/client/` to use explicit
  unicode string literals.
* Gets rid of implicit imports of `salt.utils` (e.g. `from salt.utils
  import foo` becomes `import salt.utils.foo as foo`).
* Renames the `test.rand_str` function to `test.random_hash` to more
  accurately reflect what it does
* Modifies `salt.utils.stringutils.random()` (née `salt.utils.rand_string()`)
  such that it returns a string matching the passed size. Previously
  this function would get `size` bytes from `os.urandom()`,
  base64-encode it, and return the result, which would in most cases not
  be equal to the passed size.
2017-08-08 13:33:43 -05:00

74 lines
2.3 KiB
Python

# -*- encoding: utf-8 -**
from __future__ import absolute_import, print_function
# Import system libs
import sys
import datetime
# Import salt libs
import salt.config
import salt.client.raet
try:
opts = salt.config.master_config('/etc/salt/master')
except OSError:
print('Could not open master config. Do you need to be root?')
sys.exit(1)
class SwarmController(object):
'''
A controlling class for instantiating and controlling worker procs
'''
def __init__(self, opts):
self.opts = opts
self.client = salt.client.raet.LocalClient(mopts=opts)
self.total_complete = 0
self.run_time = 90 # The number of seconds to run for
self.reqs_sec = 5000 # The number of requests / second to shoot for
self.granularity = 200 # Re-calibrate once for this many runs
self.period_sleep = 0.01 # The number of seconds to initially sleep between pubs
self.ramp_sleep = 0.001 # The number of seconds to ramp up up or down by per calibration
self.start_time = None # The timestamp for the initiation of the test run
def run(self):
'''
Run the sequence in a loop
'''
last_check = 0
self.start_time = datetime.datetime.now()
goal = self.reqs_sec * self.run_time
while True:
self.fire_it()
last_check += 1
if last_check > self.granularity:
self.calibrate()
last_check = 0
if self.total_complete > goal:
print('Test complete')
break
def fire_it(self):
'''
Send the pub!
'''
self.client.pub('silver', 'test.ping')
self.total_complete += 1
def calibrate(self):
'''
Re-calibrate the speed
'''
elapsed_time = datetime.datetime.now() - self.start_time
#remaining_time = self.run_time - elapsed_time
#remaining_requests = (self.reqs_sec * self.run_time) - self.total_complete
# Figure out what the reqs/sec has been up to this point and then adjust up or down
runtime_reqs_sec = self.total_complete / elapsed_time.total_seconds()
print('Recalibrating. Current reqs/sec: {0}'.format(runtime_reqs_sec))
return
controller = SwarmController(opts)
controller.run()