prompt
large_stringlengths 72
9.34k
| completion
large_stringlengths 0
7.61k
|
|---|---|
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
<|fim_middle|>
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | return bindata |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
<|fim_middle|>
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth) |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
<|fim_middle|>
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | log.debug("packet collision detected on channel %d" % (frequency,)) |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
<|fim_middle|>
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | p = random.randint(-40, -20) |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
<|fim_middle|>
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | p = random.randint(-90, -80) |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def <|fim_middle|>(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | __init__ |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def <|fim_middle|>(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | _recv |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def <|fim_middle|>(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | set_configuration |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def <|fim_middle|>(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | binsend |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def <|fim_middle|>(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | binrecv |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def <|fim_middle|>(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | __init__ |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def <|fim_middle|>(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | _get_radio |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def <|fim_middle|>(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | _dispatcher |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def <|fim_middle|>(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | get_radio_pair |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def <|fim_middle|>(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | get_spectrum |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def <|fim_middle|>(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | get_frequency_range |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def <|fim_middle|>(self):
return self.bandwidth_range
def get_power_range(self):
return self.power_range
<｜fim▁end｜> | get_bandwidth_range |
<|file_name|>simulation.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2015 SensorLab, Jozef Stefan Institute http://sensorlab.ijs.si
#
# Written by Tomaz Solc, [email protected]
#
# This work has been partially funded by the European Community through the
# 7th Framework Programme project CREW (FP7-ICT-2009-258301).
#
# 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 3 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, see http://www.gnu.org/licenses/
import logging
import Queue
import random
import time
from spectrumwars.testbed import TestbedBase, RadioBase, RadioTimeout, RadioError, TestbedError, RadioPacket
log = logging.getLogger(__name__)
class Radio(RadioBase):
RECEIVE_TIMEOUT = 2.
def __init__(self, addr, dispatcher, send_delay):
super(Radio, self).__init__()
self.addr = addr
self.neighbor = None
self.dispatcher = dispatcher
self.q = Queue.Queue()
self.frequency = 0
self.bandwidth = 0
self.send_delay = send_delay
def _recv(self, addr, bindata, frequency, bandwidth):
if self.frequency == frequency and self.bandwidth == bandwidth and self.addr == addr:
self.q.put(bindata)
def set_configuration(self, frequency, bandwidth, power):
self.frequency = frequency
self.bandwidth = bandwidth
def binsend(self, bindata):
self.dispatcher(self.neighbor, bindata, self.frequency, self.bandwidth)
time.sleep(self.send_delay)
def binrecv(self, timeout=None):
if timeout is None:
timeout = self.RECEIVE_TIMEOUT
try:
bindata = self.q.get(True, timeout)
except Queue.Empty:
raise RadioTimeout
else:
return bindata
class Testbed(TestbedBase):
RADIO_CLASS = Radio
def __init__(self, send_delay=.1, frequency_range=64, bandwidth_range=10, power_range=10, packet_size=1024):
self.send_delay = float(send_delay)
self.frequency_range = int(frequency_range)
self.bandwidth_range = int(bandwidth_range)
self.power_range = int(power_range)
self.RADIO_CLASS.PACKET_SIZE = int(packet_size) + 1
self.radios = []
# for each channel, we keep the timestamp of the last
# transmission. we use this for simulated spectrum sensing and
# for detecting collisions.
self.channels = [0] * self.frequency_range
self.i = 0
def _get_radio(self):
r = Radio(self.i, self._dispatcher, self.send_delay)
self.radios.append(r)
self.i += 1
return r
def _dispatcher(self, addr, bindata, frequency, bandwidth):
now = self.time()
has_collision = (now - self.channels[frequency]) > self.send_delay
self.channels[frequency] = now
if has_collision:
# note that when packets collide, the first one goes
# through while the later ones fail. this is different
# than in reality: all should fail. But this would
# be complicated to implement in practice.
for radio in self.radios:
radio._recv(addr, bindata, frequency, bandwidth)
else:
log.debug("packet collision detected on channel %d" % (frequency,))
def get_radio_pair(self):
dst = self._get_radio()
src = self._get_radio()
dst.neighbor = src.addr
src.neighbor = dst.addr
return dst, src
def get_spectrum(self):
spectrum = []
now = self.time()
for time in self.channels:
if now - time < .5:
p = random.randint(-40, -20)
else:
p = random.randint(-90, -80)
spectrum.append(p)
return tuple(spectrum)
def get_frequency_range(self):
return self.frequency_range
def get_bandwidth_range(self):
return self.bandwidth_range
def <|fim_middle|>(self):
return self.power_range
<｜fim▁end｜> | get_power_range |
<|file_name|>easy_install-script.py<|end_file_name|><｜fim▁begin｜>#!D:\PycharmProjects\UFT\Scripts\python.exe
# EASY-INSTALL-ENTRY-SCRIPT: 'setuptools==0.6c11','console_scripts','easy_install'
__requires__ = 'setuptools==0.6c11'
import sys
from pkg_resources import load_entry_point<｜fim▁hole｜>
sys.exit(
load_entry_point('setuptools==0.6c11', 'console_scripts', 'easy_install')()
)<｜fim▁end｜> | |
<|file_name|>268-missing-number.py<|end_file_name|><｜fim▁begin｜>class Solution(object):
def missingNumber(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
xor = len(nums)
<｜fim▁hole｜> return xor
inputs = [
[0],
[1],
[3,0,1],
[9,6,4,2,3,5,7,0,1]
]
s = Solution()
for i in inputs:
print s.missingNumber(i)<｜fim▁end｜> | for i, n in enumerate(nums):
xor ^= n
xor ^= i
|
<|file_name|>268-missing-number.py<|end_file_name|><｜fim▁begin｜>class Solution(object):
<|fim_middle|>
inputs = [
[0],
[1],
[3,0,1],
[9,6,4,2,3,5,7,0,1]
]
s = Solution()
for i in inputs:
print s.missingNumber(i)
<｜fim▁end｜> | def missingNumber(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
xor = len(nums)
for i, n in enumerate(nums):
xor ^= n
xor ^= i
return xor |
<|file_name|>268-missing-number.py<|end_file_name|><｜fim▁begin｜>class Solution(object):
def missingNumber(self, nums):
<|fim_middle|>
inputs = [
[0],
[1],
[3,0,1],
[9,6,4,2,3,5,7,0,1]
]
s = Solution()
for i in inputs:
print s.missingNumber(i)
<｜fim▁end｜> | """
:type nums: List[int]
:rtype: int
"""
xor = len(nums)
for i, n in enumerate(nums):
xor ^= n
xor ^= i
return xor |
<|file_name|>268-missing-number.py<|end_file_name|><｜fim▁begin｜>class Solution(object):
def <|fim_middle|>(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
xor = len(nums)
for i, n in enumerate(nums):
xor ^= n
xor ^= i
return xor
inputs = [
[0],
[1],
[3,0,1],
[9,6,4,2,3,5,7,0,1]
]
s = Solution()
for i in inputs:
print s.missingNumber(i)
<｜fim▁end｜> | missingNumber |
<|file_name|>test.py<|end_file_name|><｜fim▁begin｜><｜fim▁hole｜># Copyright (c) 2005, Jeremiah Fincher
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions, and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions, and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the author of this software nor the name of
# contributors to this software may be used to endorse or promote products
# derived from this software without specific prior written consent.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###
from supybot.test import *
class MyChannelLoggerTestCase(PluginTestCase):
plugins = ('MyChannelLogger',)
# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:<｜fim▁end｜> | ### |
<|file_name|>test.py<|end_file_name|><｜fim▁begin｜>###
# Copyright (c) 2005, Jeremiah Fincher
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions, and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions, and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the author of this software nor the name of
# contributors to this software may be used to endorse or promote products
# derived from this software without specific prior written consent.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###
from supybot.test import *
class MyChannelLoggerTestCase(PluginTestCase):
<|fim_middle|>
# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
<｜fim▁end｜> | plugins = ('MyChannelLogger',) |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \<｜fim▁hole｜> self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass<｜fim▁end｜> | if ping is not None \
else SocketPing()
|
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
<|fim_middle|>
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval) |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
<|fim_middle|>
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer() |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
<|fim_middle|>
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | return self._ping_interval |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
<|fim_middle|>
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer() |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
<|fim_middle|>
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | if self._ping is None:
return 0
return self._ping.max_ping_time |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
<|fim_middle|>
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | if self._ping is not None:
self._ping.max_ping_time = value |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
<|fim_middle|>
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | return self._stats |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
<|fim_middle|>
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | with self._server_lock:
return set(self._servers) |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
<|fim_middle|>
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
<|fim_middle|>
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | server = self._rule.choose()
return server |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
<|fim_middle|>
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | self._logger.debug("Marking server down: %s", server)
server._is_alive = False |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
<|fim_middle|>
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
<|fim_middle|>
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
<|fim_middle|>
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results) |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
<|fim_middle|>
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start() |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
<|fim_middle|>
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | with self._lock:
self._ping_timer_running = False
self._ping_timer = None |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
<|fim_middle|>
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval) |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
<|fim_middle|>
<｜fim▁end｜> | def get_server_stats(self, server):
pass |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
<|fim_middle|>
<｜fim▁end｜> | pass |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
<|fim_middle|>
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | self._start_ping_timer() |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
<|fim_middle|>
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | self._stop_ping_timer()
self._start_ping_timer() |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
<|fim_middle|>
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | return 0 |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
<|fim_middle|>
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | self._ping.max_ping_time = value |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
<|fim_middle|>
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | servers.add(s) |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
<|fim_middle|>
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | self._ping_all_servers() |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
<|fim_middle|>
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | is_alive = self._ping.is_alive(server)
server._is_alive = is_alive |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
<|fim_middle|>
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start() |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
<|fim_middle|>
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | is_alive = self._ping.is_alive(server)
server._is_alive = is_alive |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
<|fim_middle|>
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | self._logger.debug("Background pinger already running")
return |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def <|fim_middle|>(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | __init__ |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def <|fim_middle|>(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | ping_interval |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def <|fim_middle|>(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | ping_interval |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def <|fim_middle|>(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | max_ping_time |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def <|fim_middle|>(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | max_ping_time |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def <|fim_middle|>(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | stats |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def <|fim_middle|>(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | servers |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def <|fim_middle|>(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | reachable_servers |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def <|fim_middle|>(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | choose_server |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def <|fim_middle|>(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | mark_server_down |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def <|fim_middle|>(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | ping |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def <|fim_middle|>(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | ping_async |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def <|fim_middle|>(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | _ping_all_servers |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def <|fim_middle|>(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | _start_ping_timer |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def <|fim_middle|>(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | _stop_ping_timer |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def <|fim_middle|>(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def get_server_stats(self, server):
pass
<｜fim▁end｜> | _ping_loop |
<|file_name|>core.py<|end_file_name|><｜fim▁begin｜>import logging
import threading
import time
from ballast.discovery import ServerList
from ballast.rule import Rule, RoundRobinRule
from ballast.ping import (
Ping,
SocketPing,
PingStrategy,
SerialPingStrategy
)
class LoadBalancer(object):
DEFAULT_PING_INTERVAL = 30
MAX_PING_TIME = 3
def __init__(self, server_list, rule=None, ping_strategy=None, ping=None, ping_on_start=True):
assert isinstance(server_list, ServerList)
assert rule is None or isinstance(rule, Rule)
assert ping_strategy is None or isinstance(ping_strategy, PingStrategy)
assert ping is None or isinstance(ping, Ping)
# some locks for thread-safety
self._lock = threading.Lock()
self._server_lock = threading.Lock()
self._rule = rule \
if rule is not None \
else RoundRobinRule()
self._ping_strategy = ping_strategy \
if ping_strategy is not None \
else SerialPingStrategy()
self._ping = ping \
if ping is not None \
else SocketPing()
self.max_ping_time = self.MAX_PING_TIME
self._ping_interval = self.DEFAULT_PING_INTERVAL
self._server_list = server_list
self._servers = set()
self._stats = LoadBalancerStats()
self._rule.load_balancer = self
self._logger = logging.getLogger(self.__module__)
# start our background worker
# to periodically ping our servers
self._ping_timer_running = False
self._ping_timer = None
if ping_on_start:
self._start_ping_timer()
@property
def ping_interval(self):
return self._ping_interval
@ping_interval.setter
def ping_interval(self, value):
self._ping_interval = value
if self._ping_timer_running:
self._stop_ping_timer()
self._start_ping_timer()
@property
def max_ping_time(self):
if self._ping is None:
return 0
return self._ping.max_ping_time
@max_ping_time.setter
def max_ping_time(self, value):
if self._ping is not None:
self._ping.max_ping_time = value
@property
def stats(self):
return self._stats
@property
def servers(self):
with self._server_lock:
return set(self._servers)
@property
def reachable_servers(self):
with self._server_lock:
servers = set()
for s in self._servers:
if s.is_alive:
servers.add(s)
return servers
def choose_server(self):
# choose a server, will
# throw if there are none
server = self._rule.choose()
return server
def mark_server_down(self, server):
self._logger.debug("Marking server down: %s", server)
server._is_alive = False
def ping(self, server=None):
if server is None:
self._ping_all_servers()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def ping_async(self, server=None):
if server is None:
# self._ping_all_servers()
t = threading.Thread(name='ballast-worker', target=self._ping_all_servers)
t.daemon = True
t.start()
else:
is_alive = self._ping.is_alive(server)
server._is_alive = is_alive
def _ping_all_servers(self):
with self._server_lock:
results = self._ping_strategy.ping(
self._ping,
self._server_list
)
self._servers = set(results)
def _start_ping_timer(self):
with self._lock:
if self._ping_timer_running:
self._logger.debug("Background pinger already running")
return
self._ping_timer_running = True
self._ping_timer = threading.Thread(name='ballast-worker', target=self._ping_loop)
self._ping_timer.daemon = True
self._ping_timer.start()
def _stop_ping_timer(self):
with self._lock:
self._ping_timer_running = False
self._ping_timer = None
def _ping_loop(self):
while self._ping_timer_running:
try:
self._ping_all_servers()
except BaseException as e:
self._logger.error("There was an error pinging servers: %s", e)
time.sleep(self._ping_interval)
class LoadBalancerStats(object):
def <|fim_middle|>(self, server):
pass
<｜fim▁end｜> | get_server_stats |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):<｜fim▁hole｜>def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False<｜fim▁end｜> | return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
|
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
<|fim_middle|>
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label) |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
<|fim_middle|>
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
<|fim_middle|>
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | return self.ip < b.ip |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
<|fim_middle|>
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label) |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
<|fim_middle|>
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip) |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
<|fim_middle|>
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | self.a, self.b = sorted([a, b]) |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
<|fim_middle|>
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | return self.a.ip == that.a.ip and self.b.ip == that.b.ip |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
<|fim_middle|>
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip) |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
<|fim_middle|>
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | return CJDNS_IP_REGEX.match(ip) |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
<|fim_middle|>
<｜fim▁end｜> | try:
return int(version) < 30
except ValueError:
return False |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
<|fim_middle|>
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | raise ValueError('Invalid IP address') |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
<|fim_middle|>
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | raise ValueError('Invalid version') |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def <|fim_middle|>(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | __init__ |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def <|fim_middle|>(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | __lt__ |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def <|fim_middle|>(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | __repr__ |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def <|fim_middle|>(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | __init__ |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def <|fim_middle|>(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | __eq__ |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def <|fim_middle|>(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | __repr__ |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def <|fim_middle|>(ip):
return CJDNS_IP_REGEX.match(ip)
def valid_version(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | valid_cjdns_ip |
<|file_name|>graph.py<|end_file_name|><｜fim▁begin｜>import re
CJDNS_IP_REGEX = re.compile(r'^fc[0-9a-f]{2}(:[0-9a-f]{4}){7}$', re.IGNORECASE)
class Node(object):
def __init__(self, ip, version=None, label=None):
if not valid_cjdns_ip(ip):
raise ValueError('Invalid IP address')
if not valid_version(version):
raise ValueError('Invalid version')
self.ip = ip
self.version = int(version)
self.label = ip[-4:] or label
def __lt__(self, b):
return self.ip < b.ip
def __repr__(self):
return 'Node(ip="%s", version=%s, label="%s")' % (
self.ip,
self.version,
self.label)
class Edge(object):
def __init__(self, a, b):
self.a, self.b = sorted([a, b])
def __eq__(self, that):
return self.a.ip == that.a.ip and self.b.ip == that.b.ip
def __repr__(self):
return 'Edge(a.ip="{}", b.ip="{}")'.format(self.a.ip, self.b.ip)
def valid_cjdns_ip(ip):
return CJDNS_IP_REGEX.match(ip)
def <|fim_middle|>(version):
try:
return int(version) < 30
except ValueError:
return False
<｜fim▁end｜> | valid_version |
<|file_name|>server.py<|end_file_name|><｜fim▁begin｜>from flask import Flask, Response, make_response
from video_stream_handler import stream_handler
import logging
import cv2
# see line 398 of connectionpool.py:
logging.basicConfig(level=logging.DEBUG)
thetav = None
app = Flask(__name__, static_url_path='/public', static_folder='../')
@app.route('/video_feed')<｜fim▁hole｜>
return Response(stream_handler(cap), mimetype='multipart/x-mixed-replace; boundary=frame')
if __name__ == '__main__':
app.run(host='0.0.0.0', threaded=True)<｜fim▁end｜> | def video_feed():
cap = cv2.VideoCapture(0)
# cap.set(3, 3840)
# cap.set(4, 1920) |
<|file_name|>server.py<|end_file_name|><｜fim▁begin｜>from flask import Flask, Response, make_response
from video_stream_handler import stream_handler
import logging
import cv2
# see line 398 of connectionpool.py:
logging.basicConfig(level=logging.DEBUG)
thetav = None
app = Flask(__name__, static_url_path='/public', static_folder='../')
@app.route('/video_feed')
def video_feed():
<|fim_middle|>
if __name__ == '__main__':
app.run(host='0.0.0.0', threaded=True)
<｜fim▁end｜> | cap = cv2.VideoCapture(0)
# cap.set(3, 3840)
# cap.set(4, 1920)
return Response(stream_handler(cap), mimetype='multipart/x-mixed-replace; boundary=frame') |
<|file_name|>server.py<|end_file_name|><｜fim▁begin｜>from flask import Flask, Response, make_response
from video_stream_handler import stream_handler
import logging
import cv2
# see line 398 of connectionpool.py:
logging.basicConfig(level=logging.DEBUG)
thetav = None
app = Flask(__name__, static_url_path='/public', static_folder='../')
@app.route('/video_feed')
def video_feed():
cap = cv2.VideoCapture(0)
# cap.set(3, 3840)
# cap.set(4, 1920)
return Response(stream_handler(cap), mimetype='multipart/x-mixed-replace; boundary=frame')
if __name__ == '__main__':
<|fim_middle|>
<｜fim▁end｜> | app.run(host='0.0.0.0', threaded=True) |
<|file_name|>server.py<|end_file_name|><｜fim▁begin｜>from flask import Flask, Response, make_response
from video_stream_handler import stream_handler
import logging
import cv2
# see line 398 of connectionpool.py:
logging.basicConfig(level=logging.DEBUG)
thetav = None
app = Flask(__name__, static_url_path='/public', static_folder='../')
@app.route('/video_feed')
def <|fim_middle|>():
cap = cv2.VideoCapture(0)
# cap.set(3, 3840)
# cap.set(4, 1920)
return Response(stream_handler(cap), mimetype='multipart/x-mixed-replace; boundary=frame')
if __name__ == '__main__':
app.run(host='0.0.0.0', threaded=True)
<｜fim▁end｜> | video_feed |
<|file_name|>727. Minimum Window Subsequence.py<|end_file_name|><｜fim▁begin｜>from collections import defaultdict
class Solution(object):
def minWindow(self, S, T):
"""
:type S: str
:type T: str
:rtype: str
"""
pre = defaultdict(list)
for i, c in enumerate(T, -1):
pre[c].append(i)
for val in pre.values():
val.reverse()
start_index = [None] * (len(T) + 1)
lo, hi = float('-inf'), 0
for i, c in enumerate(S):
start_index[-1] = i
for p in pre[c]:
if start_index[p] is not None:
start_index[p + 1] = start_index[p]
if (c == T[-1] and start_index[-2] is not None
and i - start_index[-2] < hi - lo):
lo, hi = start_index[-2], i
if lo < 0:
return ''
else:
return S[lo:hi+1]
# print(Solution().minWindow("abcdebdde", "bde"))<｜fim▁hole｜># print(Solution().minWindow("nkzcnhczmccqouqadqtmjjzltgdzthm", "bt"))
print(Solution().minWindow("cnhczmccqouqadqtmjjzl", "mm"))<｜fim▁end｜> | |
<|file_name|>727. Minimum Window Subsequence.py<|end_file_name|><｜fim▁begin｜>from collections import defaultdict
class Solution(object):
<|fim_middle|>
# print(Solution().minWindow("abcdebdde", "bde"))
# print(Solution().minWindow("nkzcnhczmccqouqadqtmjjzltgdzthm", "bt"))
print(Solution().minWindow("cnhczmccqouqadqtmjjzl", "mm"))
<｜fim▁end｜> | def minWindow(self, S, T):
"""
:type S: str
:type T: str
:rtype: str
"""
pre = defaultdict(list)
for i, c in enumerate(T, -1):
pre[c].append(i)
for val in pre.values():
val.reverse()
start_index = [None] * (len(T) + 1)
lo, hi = float('-inf'), 0
for i, c in enumerate(S):
start_index[-1] = i
for p in pre[c]:
if start_index[p] is not None:
start_index[p + 1] = start_index[p]
if (c == T[-1] and start_index[-2] is not None
and i - start_index[-2] < hi - lo):
lo, hi = start_index[-2], i
if lo < 0:
return ''
else:
return S[lo:hi+1] |
<|file_name|>727. Minimum Window Subsequence.py<|end_file_name|><｜fim▁begin｜>from collections import defaultdict
class Solution(object):
def minWindow(self, S, T):
<|fim_middle|>
# print(Solution().minWindow("abcdebdde", "bde"))
# print(Solution().minWindow("nkzcnhczmccqouqadqtmjjzltgdzthm", "bt"))
print(Solution().minWindow("cnhczmccqouqadqtmjjzl", "mm"))
<｜fim▁end｜> | """
:type S: str
:type T: str
:rtype: str
"""
pre = defaultdict(list)
for i, c in enumerate(T, -1):
pre[c].append(i)
for val in pre.values():
val.reverse()
start_index = [None] * (len(T) + 1)
lo, hi = float('-inf'), 0
for i, c in enumerate(S):
start_index[-1] = i
for p in pre[c]:
if start_index[p] is not None:
start_index[p + 1] = start_index[p]
if (c == T[-1] and start_index[-2] is not None
and i - start_index[-2] < hi - lo):
lo, hi = start_index[-2], i
if lo < 0:
return ''
else:
return S[lo:hi+1] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.