def test_same_port_twice(self):
port = 51235
with BmiClient.create_grpc_channel(
port) as channel1, BmiClient.create_grpc_channel(
port) as channel2:
assert channel1._channel.target() == b'localhost:51235'
assert channel2._channel.target() == b'localhost:51235'
def __init__(self, image, image_port=50051, host=None,
input_dir=None, output_dir=None,
user=os.getuid(), remove=True):
port = BmiClient.get_unique_port()
client = docker.from_env()
volumes = {}
self.input_dir = None
if input_dir is not None:
self.input_dir = os.path.abspath(input_dir)
volumes[self.input_dir] = {"bind": BmiClientDocker.input_mount_point, "mode": "rw"}
self.output_dir = None
if output_dir is not None:
self.output_dir = os.path.abspath(output_dir)
try:
# Create output dir ourselves, otherwise Docker will create it as root user, resulting in permission
# errors
os.mkdir(self.output_dir)
except OSError as e:
if e.errno != errno.EEXIST:
raise
volumes[self.output_dir] = {"bind": BmiClientDocker.output_mount_point, "mode": "rw"}
self.container = client.containers.run(image,
ports={str(image_port) + "/tcp": port},
volumes=volumes,
user=user,
remove=remove,
detach=True)
time.sleep(5)
super(BmiClientDocker, self).__init__(BmiClient.create_grpc_channel(port=port, host=host))
def __init__(self,
image,
image_port=55555,
host=None,
input_dir=None,
output_dir=None,
user=os.getuid(),
remove=False,
delay=5,
timeout=None,
extra_volumes=None):
port = BmiClient.get_unique_port()
client = docker.from_env()
volumes = {}
if extra_volumes is not None:
volumes.update(extra_volumes)
self.input_dir = None
if input_dir is not None:
self.input_dir = os.path.abspath(input_dir)
if not os.path.isdir(self.input_dir):
raise NotADirectoryError(input_dir)
volumes[self.input_dir] = {
"bind": BmiClientDocker.input_mount_point,
"mode": "rw"
}
self.output_dir = None
if output_dir is not None:
self.output_dir = os.path.abspath(output_dir)
try:
# Create output dir ourselves, otherwise Docker will create it as root user, resulting in permission
# errors
os.mkdir(self.output_dir)
except OSError as e:
if e.errno != errno.EEXIST:
raise
volumes[self.output_dir] = {
"bind": BmiClientDocker.output_mount_point,
"mode": "rw"
}
self.container = client.containers.run(
image,
ports={str(image_port) + "/tcp": port},
volumes=volumes,
user=user,
remove=remove,
detach=True)
time.sleep(delay)
if not remove:
# Only able to reload, read logs when container is not in auto remove mode
self.container.reload()
if self.container.status == 'exited':
exitcode = self.container.attrs["State"]["ExitCode"]
logs = self.container.logs()
msg = f'Failed to start Docker container with image {image}, Container log: {logs}'
raise DeadDockerContainerException(msg, exitcode, logs)
super(BmiClientDocker,
self).__init__(BmiClient.create_grpc_channel(port=port,
host=host),
timeout=timeout)
def make_bmi_classes(init=False):
client = BmiClient(stub=ServerWrapper(BmiServer(FlatBmiHeat())))
local = FlatBmiHeat()
if init:
numpy.random.seed(0)
client.initialize(None)
numpy.random.seed(0)
local.initialize(None)
return client, local
def __init__(self, module_name, path=None):
host = "localhost"
port = BmiClient.get_unique_port(host)
name_options = ["--name", module_name]
port_options = ["--port", str(port)]
path_options = ["--path", path] if path else []
self.pipe = subprocess.Popen(["run-bmi-server"] + name_options +
port_options + path_options,
env=dict(os.environ))
time.sleep(1)
super(BmiClientSubProcess, self).__init__(
BmiClient.create_grpc_channel(port=port, host=host))
def test_method_exception(client_method, client_request):
exc = SomeException('bmi method always fails')
model = FailingModel(exc)
client = BmiClient(stub=ServerWrapper(BmiServer(model)))
with pytest.raises(Exception) as excinfo:
getattr(client, client_method)(*client_request)
assert "bmi method always fails" in str(excinfo.value)
def __init__(self,
image,
input_dir=None,
output_dir=None,
timeout=None,
delay=0,
extra_volumes=None):
check_singularity_version()
host = 'localhost'
port = BmiClient.get_unique_port(host)
args = ["singularity", "run", "--env", f"BMI_PORT={port}"]
mount_points = {} if extra_volumes is None else extra_volumes
if input_dir is not None:
mount_points[input_dir] = BmiClientSingularity.INPUT_MOUNT_POINT
self.input_dir = abspath(input_dir)
if any(mount_points):
args += [
"--bind",
','.join([hp + ':' + ip for hp, ip in mount_points.items()])
]
if output_dir is not None:
self.output_dir = abspath(output_dir)
try:
# Create output dir ourselves or singularity will complain
os.mkdir(self.output_dir)
except OSError as e:
if e.errno != errno.EEXIST:
raise e
args += [
"--bind",
output_dir + ':' + BmiClientSingularity.OUTPUT_MOUNT_POINT
]
args.append(image)
logging.info(f'Running {image} singularity container on port {port}')
self.container = subprocess.Popen(args, preexec_fn=os.setsid)
time.sleep(delay)
super(BmiClientSingularity,
self).__init__(BmiClient.create_grpc_channel(port=port,
host=host),
timeout=timeout)
def __init__(self, image, input_dir=None, output_dir=None):
check_singularity_version()
host = 'localhost'
port = BmiClient.get_unique_port(host)
args = [
"singularity",
"run",
]
if input_dir is not None:
self.input_dir = abspath(input_dir)
args += [
"--bind",
input_dir + ':' + BmiClientSingularity.INPUT_MOUNT_POINT
]
if output_dir is not None:
self.output_dir = abspath(output_dir)
try:
# Create output dir ourselves or singularity will complain
os.mkdir(self.output_dir)
except OSError as e:
if e.errno != errno.EEXIST:
raise e
args += [
"--bind",
output_dir + ':' + BmiClientSingularity.OUTPUT_MOUNT_POINT
]
args.append(image)
env = os.environ.copy()
env['BMI_PORT'] = str(port)
logging.info(f'Running {image} singularity container on port {port}')
self.container = subprocess.Popen(args,
stderr=sys.stderr,
stdout=sys.stdout,
env=env,
preexec_fn=os.setsid)
super(BmiClientSingularity, self).__init__(
BmiClient.create_grpc_channel(port=port, host=host))
def test_custom(self):
with BmiClient.create_grpc_channel(51234, 'somehost') as channel:
target = channel._channel.target()
assert target == b'somehost:51234'
def test_defaults(self):
with BmiClient.create_grpc_channel() as channel:
target = channel._channel.target()
assert target == b'localhost:50051'
def bmiclient(self, bmimodel):
client = BmiClient(stub=ServerWrapper(BmiServer(bmimodel)))
yield client
del client
def bmiclient(self):
model = UnstructuredGridBmiModel()
client = BmiClient(stub=ServerWrapper(BmiServer(model)))
yield client
del client
def bmiclient(self):
model = Structured2DQuadrilateralsGridModel()
client = BmiClient(stub=ServerWrapper(BmiServer(model)))
yield client
del client
def bmiclient(self):
model = Rect2DGridModel()
client = BmiClient(stub=ServerWrapper(BmiServer(model)))
yield client
del client