def checkIsPortFree(self):
"""This might be flaky unless this test is run with a portserver."""
# The port should be free initially.
port = portpicker.pick_unused_port()
self.assertTrue(portpicker.is_port_free(port))
cases = [
(socket.AF_INET, socket.SOCK_STREAM, None),
(socket.AF_INET6, socket.SOCK_STREAM, 0),
(socket.AF_INET6, socket.SOCK_STREAM, 1),
(socket.AF_INET, socket.SOCK_DGRAM, None),
(socket.AF_INET6, socket.SOCK_DGRAM, 0),
(socket.AF_INET6, socket.SOCK_DGRAM, 1),
]
for (sock_family, sock_type, v6only) in cases:
# Occupy the port on a subset of possible protocols.
try:
sock = socket.socket(sock_family, sock_type, 0)
except socket.error:
print('Kernel does not support sock_family=%d' % sock_family,
file=sys.stderr)
# Skip this case, since we cannot occupy a port.
continue
if not hasattr(socket, 'IPPROTO_IPV6'):
v6only = None
if v6only is not None:
try:
sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY,
v6only)
except socket.error:
print('Kernel does not support IPV6_V6ONLY=%d' % v6only,
file=sys.stderr)
# Don't care; just proceed with the default.
# Socket may have been taken in the mean time, so catch the
# socket.error with errno set to EADDRINUSE and skip this
# attempt.
try:
sock.bind(('', port))
except socket.error as e:
if e.errno == errno.EADDRINUSE:
raise portpicker.NoFreePortFoundError
raise
# The port should be busy.
self.assertFalse(portpicker.is_port_free(port))
sock.close()
# Now it's free again.
self.assertTrue(portpicker.is_port_free(port))
def DetermineLocalPort(port_arg=0):
if not port_arg:
port_arg = portpicker.pick_unused_port()
if not portpicker.is_port_free(port_arg):
raise LocalPortUnavailableError('Local port [%d] is not available.' %
port_arg)
return port_arg
def startStopSim():
global PORT, client, cameras
if client is None:
# No client, then Start
PORT = int(request.args.get('port'))
print("waiting")
while portpicker.is_port_free(PORT):
sleep(5 * againIn)
print(".")
client = sim.simxStart('127.0.0.1', PORT, True, True, 5000, 5)
verboseResp(client, "simxStart")
return str(client)
else:
# There is a client, then Stop
stop()
sleep(.5)
response = sim.simxSetIntegerSignal(client, 'doClose', 1,
sim.simx_opmode_oneshot_wait)
verboseResp(response, "simxSetIntegerSignal doClose")
try:
finish()
except:
verboseResp("already finished?", "finish")
reset()
if response == -1:
return "-1"
else:
return "0"
def _GetLocalHostPort(self, args):
local_port = (int(args.local_host_port.port)
if args.local_host_port.port else 0)
if not local_port:
local_port = portpicker.pick_unused_port()
log.Print('Picking local unused port [%d].' % local_port)
if not portpicker.is_port_free(local_port):
raise LocalHostPortUnavailableError(
'Local port [%d] is not available.' % local_port)
return args.local_host_port.host, local_port
def testIsPortFree(self):
"""This might be flaky unless this test is run with a portserver."""
# The port should be free initially.
port = portpicker.pick_unused_port()
self.assertTrue(portpicker.is_port_free(port))
cases = [
(socket.AF_INET, socket.SOCK_STREAM, None),
(socket.AF_INET6, socket.SOCK_STREAM, 0),
(socket.AF_INET6, socket.SOCK_STREAM, 1),
(socket.AF_INET, socket.SOCK_DGRAM, None),
(socket.AF_INET6, socket.SOCK_DGRAM, 0),
(socket.AF_INET6, socket.SOCK_DGRAM, 1),
]
for (sock_family, sock_type, v6only) in cases:
# Occupy the port on a subset of possible protocols.
try:
sock = socket.socket(sock_family, sock_type, 0)
except socket.error:
print('Kernel does not support sock_family=%d' % sock_family,
file=sys.stderr)
# Skip this case, since we cannot occupy a port.
continue
if v6only is not None:
try:
sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY,
v6only)
except socket.error:
print('Kernel does not support IPV6_V6ONLY=%d' % v6only,
file=sys.stderr)
# Don't care; just proceed with the default.
sock.bind(('', port))
# The port should be busy.
self.assertFalse(portpicker.is_port_free(port))
sock.close()
# Now it's free again.
self.assertTrue(portpicker.is_port_free(port))
def getUnusedPort():
"""Returns an unused TCP port on the local host inside the defined port range.
To be used when starting peer SAS webserver or other database webserver.
"""
config = _GetSharedTestConfig()
if config.min_port < 0:
return portpicker.pick_unused_port()
global _ports
# Find the first available port in the defined range.
for p in xrange(config.min_port, config.max_port):
if p not in _ports and portpicker.is_port_free(p):
_ports.add(p)
return p
raise AssertionError('No available new ports')
def contiguous_ports(cls, guests=1, attempts=40):
"""Returns a Portconfig with adjacent ports"""
for _ in range(attempts):
start = portpicker.pick_unused_port()
others = [start + j for j in range(1, 2 + guests * 2)]
if all(portpicker.is_port_free(p) for p in others):
server_ports = [start, others.pop(0)]
player_ports = []
while others:
player_ports.append([others.pop(0), others.pop(0)])
pc = cls(server_ports=server_ports, player_ports=player_ports)
pc._picked_ports.append(start)
return pc
raise portpicker.NoFreePortFoundError()
def DefaultPortIfAvailable():
"""Returns default port if available.
Raises:
EmulatorArgumentsError: if port is not available.
Returns:
int, default port
"""
if portpicker.is_port_free(_DEFAULT_PORT):
return _DEFAULT_PORT
else:
raise EmulatorArgumentsError(
'Default emulator port [{}] is already in use'.format(_DEFAULT_PORT))
def pick_contiguous_unused_ports(num_ports,
retry_interval_secs=3,
retry_attempts=5):
"""Reserves and returns a list of `num_ports` contiguous unused ports."""
for _ in range(retry_attempts):
start_port = portpicker.pick_unused_port()
if start_port is not None:
ports = [start_port + p for p in range(num_ports)]
if all(portpicker.is_port_free(p) for p in ports):
return ports
else:
return_ports(ports)
time.sleep(retry_interval_secs)
raise RuntimeError("Unable to obtain %d contiguous unused ports." %
num_ports)
def pick_contiguous_unused_ports(num_ports,
retry_interval_secs=1,
retry_attempts=5):
"""Reserves and returns a list of `num_ports` contiguous unused ports."""
if num_ports <= 0:
raise ValueError("Number of ports, must be >= 1, got: %s" % num_ports)
for _ in range(retry_attempts):
start_port = portpicker.pick_unused_port()
if start_port is not None:
ports = [start_port + p for p in range(num_ports)]
if all(portpicker.is_port_free(p) for p in ports):
_contiguous_ports.update(ports[1:])
return ports
else:
portpicker.return_port(start_port)
time.sleep(retry_interval_secs)
raise RuntimeError("Unable to obtain %d contiguous unused ports." %
num_ports)
def is_port_open(port):
if not is_port_free(port):
return True
else:
return False
def get_free_port(start, end):
return [port for port in range(start, end) if is_port_free(port)]
def human():
"""Run a host which expects one player to connect remotely."""
run_config = run_configs.get()
map_inst = maps.get(FLAGS.map)
if not FLAGS.rgb_screen_size or not FLAGS.rgb_minimap_size:
logging.info(
"Use --rgb_screen_size and --rgb_minimap_size if you want rgb "
"observations.")
ports = [FLAGS.config_port + p for p in range(5)] # tcp + 2 * num_players
if not all(portpicker.is_port_free(p) for p in ports):
sys.exit("Need 5 free ports after the config port.")
proc = None
ssh_proc = None
tcp_conn = None
udp_sock = None
try:
proc = run_config.start(extra_ports=ports[1:],
timeout_seconds=300,
host=FLAGS.host,
window_loc=(50, 50))
tcp_port = ports[0]
settings = {
"remote": FLAGS.remote,
"game_version": proc.version.game_version,
"realtime": FLAGS.realtime,
"map_name": map_inst.name,
"map_path": map_inst.path,
"map_data": map_inst.data(run_config),
"ports": {
"server": {
"game": ports[1],
"base": ports[2]
},
"client": {
"game": ports[3],
"base": ports[4]
},
}
}
create = sc_pb.RequestCreateGame(
realtime=settings["realtime"],
local_map=sc_pb.LocalMap(map_path=settings["map_path"]))
create.player_setup.add(type=sc_pb.Participant)
create.player_setup.add(type=sc_pb.Participant)
controller = proc.controller
controller.save_map(settings["map_path"], settings["map_data"])
controller.create_game(create)
if FLAGS.remote:
ssh_proc = lan_sc2_env.forward_ports(
FLAGS.remote, proc.host, [settings["ports"]["client"]["base"]],
[tcp_port, settings["ports"]["server"]["base"]])
print("-" * 80)
print("Join: play_vs_agent --host %s --config_port %s" %
(proc.host, tcp_port))
print("-" * 80)
tcp_conn = lan_sc2_env.tcp_server(
lan_sc2_env.Addr(proc.host, tcp_port), settings)
if FLAGS.remote:
udp_sock = lan_sc2_env.udp_server(
lan_sc2_env.Addr(proc.host,
settings["ports"]["client"]["game"]))
lan_sc2_env.daemon_thread(
lan_sc2_env.tcp_to_udp,
(tcp_conn, udp_sock,
lan_sc2_env.Addr(proc.host,
settings["ports"]["server"]["game"])))
lan_sc2_env.daemon_thread(lan_sc2_env.udp_to_tcp,
(udp_sock, tcp_conn))
join = sc_pb.RequestJoinGame()
join.shared_port = 0 # unused
join.server_ports.game_port = settings["ports"]["server"]["game"]
join.server_ports.base_port = settings["ports"]["server"]["base"]
join.client_ports.add(game_port=settings["ports"]["client"]["game"],
base_port=settings["ports"]["client"]["base"])
join.race = sc2_env.Race[FLAGS.user_race]
join.player_name = FLAGS.user_name
if FLAGS.render:
join.options.raw = True
join.options.score = True
if FLAGS.feature_screen_size and FLAGS.feature_minimap_size:
fl = join.options.feature_layer
fl.width = 24
FLAGS.feature_screen_size.assign_to(fl.resolution)
FLAGS.feature_minimap_size.assign_to(fl.minimap_resolution)
if FLAGS.rgb_screen_size and FLAGS.rgb_minimap_size:
FLAGS.rgb_screen_size.assign_to(join.options.render.resolution)
FLAGS.rgb_minimap_size.assign_to(
join.options.render.minimap_resolution)
controller.join_game(join)
if FLAGS.render:
renderer = renderer_human.RendererHuman(fps=FLAGS.fps,
render_feature_grid=False)
renderer.run(run_configs.get(), controller, max_episodes=1)
else: # Still step forward so the Mac/Windows renderer works.
while True:
frame_start_time = time.time()
if not FLAGS.realtime:
controller.step()
obs = controller.observe()
if obs.player_result:
break
time.sleep(
max(0, frame_start_time - time.time() + 1 / FLAGS.fps))
except KeyboardInterrupt:
pass
finally:
if tcp_conn:
tcp_conn.close()
if proc:
proc.close()
if udp_sock:
udp_sock.close()
if ssh_proc:
ssh_proc.terminate()
for _ in range(5):
if ssh_proc.poll() is not None:
break
time.sleep(1)
if ssh_proc.poll() is None:
ssh_proc.kill()
ssh_proc.wait()
def human():
"""Run a host which expects one player to connect remotely."""
run_config = run_configs.get()
map_inst = maps.get(FLAGS.map)
if not FLAGS.rgb_screen_size or not FLAGS.rgb_minimap_size:
logging.info("Use --rgb_screen_size and --rgb_minimap_size if you want rgb "
"observations.")
while True:
start_port = portpicker.pick_unused_port()
ports = [start_port + p for p in range(4)] # 2 * num_players
if all(portpicker.is_port_free(p) for p in ports):
break
host_proc = run_config.start(extra_ports=ports, host=FLAGS.host,
timeout_seconds=300, window_loc=(50, 50))
client_proc = run_config.start(extra_ports=ports, host=FLAGS.host,
connect=False, window_loc=(700, 50))
create = sc_pb.RequestCreateGame(
realtime=FLAGS.realtime, local_map=sc_pb.LocalMap(map_path=map_inst.path))
create.player_setup.add(type=sc_pb.Participant)
create.player_setup.add(type=sc_pb.Participant)
controller = host_proc.controller
controller.save_map(map_inst.path, map_inst.data(run_config))
controller.create_game(create)
print("-" * 80)
print("Join host: play_vs_agent --map %s --host %s --host_port %s "
"--lan_port %s" % (FLAGS.map, FLAGS.host, client_proc.port, start_port))
print("-" * 80)
join = sc_pb.RequestJoinGame()
join.shared_port = 0 # unused
join.server_ports.game_port = ports.pop(0)
join.server_ports.base_port = ports.pop(0)
join.client_ports.add(game_port=ports.pop(0), base_port=ports.pop(0))
join.race = sc2_env.Race[FLAGS.user_race]
if FLAGS.render:
join.options.raw = True
join.options.score = True
if FLAGS.feature_screen_size and FLAGS.feature_minimap_size:
fl = join.options.feature_layer
fl.width = 24
fl.resolution.x = FLAGS.feature_screen_size
fl.resolution.y = FLAGS.feature_screen_size
fl.minimap_resolution.x = FLAGS.feature_minimap_size
fl.minimap_resolution.y = FLAGS.feature_minimap_size
if FLAGS.rgb_screen_size and FLAGS.rgb_minimap_size:
join.options.render.resolution.x = FLAGS.rgb_screen_size
join.options.render.resolution.y = FLAGS.rgb_screen_size
join.options.render.minimap_resolution.x = FLAGS.rgb_minimap_size
join.options.render.minimap_resolution.y = FLAGS.rgb_minimap_size
controller.join_game(join)
if FLAGS.render:
renderer = renderer_human.RendererHuman(
fps=FLAGS.fps, render_feature_grid=False)
renderer.run(run_configs.get(), controller, max_episodes=1)
else: # Still step forward so the Mac/Windows renderer works.
try:
while True:
frame_start_time = time.time()
if not FLAGS.realtime:
controller.step()
obs = controller.observe()
if obs.player_result:
break
time.sleep(max(0, frame_start_time - time.time() + 1 / FLAGS.fps))
except KeyboardInterrupt:
pass
for p in [host_proc, client_proc]:
p.close()
def server():
"""Run a host which expects one player to connect remotely."""
run_config = run_configs.get()
map_inst = maps.get(FLAGS.map)
if not FLAGS.rgb_screen_size or not FLAGS.rgb_minimap_size:
logging.info(
"Use --rgb_screen_size and --rgb_minimap_size if you want rgb "
"observations.")
ports = [FLAGS.port0, FLAGS.port1, FLAGS.port2, FLAGS.port3, FLAGS.port4]
if not all(portpicker.is_port_free(p) for p in ports):
sys.exit("Need 5 free ports after the config port.")
proc = None
tcp_conn = None
try:
proc = run_config.start(extra_ports=ports[1:],
timeout_seconds=300,
host=FLAGS.host,
window_loc=(50, 50))
tcp_port = ports[0]
settings = {
"remote": False,
"game_version": proc.version.game_version,
"realtime": FLAGS.realtime,
"map_name": map_inst.name,
"map_path": map_inst.path,
"map_data": map_inst.data(run_config),
"ports": {
"server": {
"game": ports[1],
"base": ports[2]
},
"client": {
"game": ports[3],
"base": ports[4]
},
}
}
create = sc_pb.RequestCreateGame(
realtime=settings["realtime"],
local_map=sc_pb.LocalMap(map_path=settings["map_path"]),
disable_fog=FLAGS.disable_fog)
create.player_setup.add(type=sc_pb.Participant)
create.player_setup.add(type=sc_pb.Participant)
controller = proc.controller
controller.save_map(settings["map_path"], settings["map_data"])
controller.create_game(create)
print("-" * 80)
print("Join: agent_vs_agent --host %s --config_port %s" %
(proc.host, tcp_port))
print("-" * 80)
tcp_conn = lan_sc2_env.tcp_server(
lan_sc2_env.Addr(proc.host, tcp_port), settings)
join = sc_pb.RequestJoinGame()
join.shared_port = 0 # unused
join.server_ports.game_port = settings["ports"]["server"]["game"]
join.server_ports.base_port = settings["ports"]["server"]["base"]
join.client_ports.add(game_port=settings["ports"]["client"]["game"],
base_port=settings["ports"]["client"]["base"])
join.race = sc2_env.Race[FLAGS.agent_race]
join.options.raw = True
join.options.score = True
if FLAGS.feature_screen_size and FLAGS.feature_minimap_size:
fl = join.options.feature_layer
fl.width = 24
FLAGS.feature_screen_size.assign_to(fl.resolution)
FLAGS.feature_minimap_size.assign_to(fl.minimap_resolution)
if FLAGS.rgb_screen_size and FLAGS.rgb_minimap_size:
FLAGS.rgb_screen_size.assign_to(join.options.render.resolution)
FLAGS.rgb_minimap_size.assign_to(
join.options.render.minimap_resolution)
controller.join_game(join)
with lan_server_sc2_env.LanServerSC2Env(
race=sc2_env.Race[FLAGS.agent_race],
step_mul=FLAGS.step_mul,
agent_interface_format=sc2_env.parse_agent_interface_format(
feature_screen=FLAGS.feature_screen_size,
feature_minimap=FLAGS.feature_minimap_size,
rgb_screen=FLAGS.rgb_screen_size,
rgb_minimap=FLAGS.rgb_minimap_size,
action_space=FLAGS.action_space,
use_feature_units=FLAGS.use_feature_units),
visualize=False,
controller=controller,
map_name=FLAGS.map) as env:
agent_module, agent_name = FLAGS.agent.rsplit(".", 1)
agent_cls = getattr(importlib.import_module(agent_module),
agent_name)
agent_kwargs = {}
if FLAGS.agent_config:
agent_kwargs['config_path'] = FLAGS.agent_config
agents = [agent_cls(**agent_kwargs)]
try:
run_loop(agents, env, FLAGS.max_steps)
except lan_server_sc2_env.RestartException:
pass
if FLAGS.save_replay:
env.save_replay(agent_cls.__name__)
finally:
if tcp_conn:
tcp_conn.close()
if proc:
proc.close()
import portpicker
if __name__ == '__main__':
test_port = portpicker.is_port_free(55555)
print(test_port)
def Run(self, args):
if 'all' in args.emulators:
if len(args.emulators) > 1:
raise util.EmulatorArgumentsError(
"Cannot specify 'all' with other emulators")
if args.route_to_public:
raise util.EmulatorArgumentsError(
'Cannot specify --route-to-public and --emulators=all')
else:
unknown_emulators = [x for x in args.emulators
if x not in config.EMULATORS]
if unknown_emulators:
raise util.EmulatorArgumentsError('Specified unrecognized emulators: '
','.join(unknown_emulators))
proxy_port = args.proxy_port
if args.proxy_port is None:
proxy_port = util.DefaultPortIfAvailable()
if not portpicker.is_port_free(proxy_port):
raise util.EmulatorArgumentsError(
'Specified proxy port [{}] is not available'.format(proxy_port))
util.EnsureComponentIsInstalled('emulator-reverse-proxy',
'gcloud emulators start')
for flag, emulator in six.iteritems(config.EMULATORS):
title = emulator.emulator_title
component = emulator.emulator_component
if (args.emulators is not None and
(flag in args.emulators or 'all' in args.emulators)):
java.RequireJavaInstalled(title)
util.EnsureComponentIsInstalled(component, title)
with contextlib.ExitStack() as stack:
local_emulator_ports = {}
for emulator in args.emulators:
port = portpicker.pick_unused_port()
local_emulator_ports[emulator] = port
stack.enter_context(config.EMULATORS[emulator].Start(port))
_, routes_config_file = tempfile.mkstemp()
config.WriteRoutesConfig(config.EMULATORS, routes_config_file)
log.status.Print(
'routes configuration written to file: {}'.format(routes_config_file))
proxy_config = config.ProxyConfiguration(local_emulator_ports,
args.route_to_public,
proxy_port)
_, proxy_config_file = tempfile.mkstemp()
proxy_config.WriteJsonToFile(proxy_config_file)
log.status.Print(
'proxy configuration written to file: {}'.format(proxy_config_file))
# TODO(b/35872500) for some reason, in this case, this will block. Maybe
# we need to flush something, maybe not. Regardless, this is fine for
# now, but would be nice for it to not block like everything else
with proxy_util.StartEmulatorProxy(
args=[routes_config_file, proxy_config_file]) as proxy_process:
# This will block the console
util.PrefixOutput(proxy_process, 'emulator-reverse-proxy')
def testIsPortFreeException(self):
port = portpicker.pick_unused_port()
with mock.patch.object(socket, 'socket') as mock_sock:
mock_sock.side_effect = socket.error('fake socket error', 0)
self.assertFalse(portpicker.is_port_free(port))