def open_block(tuple):
"""Blocks until a Stream completes its connection attempt, either
succeeding or failing. 'tuple' should be the tuple returned by
Stream.open(). Returns a tuple of the same form.
Typical usage:
error, stream = Stream.open_block(Stream.open("tcp:1.2.3.4:5"))"""
error, stream = tuple
if not error:
while True:
error = stream.connect()
if error != errno.EAGAIN:
break
stream.run()
poller = ovs.poller.Poller()
stream.run_wait()
stream.connect_wait(poller)
poller.block()
assert error != errno.EINPROGRESS
if error and stream:
stream.close()
stream = None
return error, stream
def open_block(error_stream):
"""Blocks until a Stream completes its connection attempt, either
succeeding or failing. (error, stream) should be the tuple returned by
Stream.open(). Returns a tuple of the same form.
Typical usage:
error, stream = Stream.open_block(Stream.open("unix:/tmp/socket"))"""
# Py3 doesn't support tuple parameter unpacking - PEP 3113
error, stream = error_stream
if not error:
while True:
error = stream.connect()
if error != errno.EAGAIN:
break
stream.run()
poller = ovs.poller.Poller()
stream.run_wait(poller)
stream.connect_wait(poller)
poller.block()
assert error != errno.EINPROGRESS
if error and stream:
stream.close()
stream = None
return error, stream
def open_block(error_stream):
"""Blocks until a Stream completes its connection attempt, either
succeeding or failing. (error, stream) should be the tuple returned by
Stream.open(). Returns a tuple of the same form.
Typical usage:
error, stream = Stream.open_block(Stream.open("unix:/tmp/socket"))"""
# Py3 doesn't support tuple parameter unpacking - PEP 3113
error, stream = error_stream
if not error:
while True:
error = stream.connect()
if sys.platform == 'win32' and error == errno.WSAEWOULDBLOCK:
# WSAEWOULDBLOCK would be the equivalent on Windows
# for EAGAIN on Unix.
error = errno.EAGAIN
if error != errno.EAGAIN:
break
stream.run()
poller = ovs.poller.Poller()
stream.run_wait(poller)
stream.connect_wait(poller)
poller.block()
if stream.socket is not None:
assert error != errno.EINPROGRESS
if error and stream:
stream.close()
stream = None
return error, stream
def open_block(tuple):
"""Blocks until a Stream completes its connection attempt, either
succeeding or failing. 'tuple' should be the tuple returned by
Stream.open(). Returns a tuple of the same form.
Typical usage:
error, stream = Stream.open_block(Stream.open("tcp:1.2.3.4:5"))"""
error, stream = tuple
if not error:
while True:
error = stream.connect()
if error != errno.EAGAIN:
break
stream.run()
poller = ovs.poller.Poller()
stream.run_wait()
stream.connect_wait(poller)
poller.block()
assert error != errno.EINPROGRESS
if error and stream:
stream.close()
stream = None
return error, stream
def open_block(error_stream):
"""Blocks until a Stream completes its connection attempt, either
succeeding or failing. (error, stream) should be the tuple returned by
Stream.open(). Returns a tuple of the same form.
Typical usage:
error, stream = Stream.open_block(Stream.open("unix:/tmp/socket"))"""
# Py3 doesn't support tuple parameter unpacking - PEP 3113
error, stream = error_stream
if not error:
while True:
error = stream.connect()
if sys.platform == 'win32' and error == errno.WSAEWOULDBLOCK:
# WSAEWOULDBLOCK would be the equivalent on Windows
# for EAGAIN on Unix.
error = errno.EAGAIN
if error != errno.EAGAIN:
break
stream.run()
poller = ovs.poller.Poller()
stream.run_wait(poller)
stream.connect_wait(poller)
poller.block()
if stream.socket is not None:
assert error != errno.EINPROGRESS
if error and stream:
stream.close()
stream = None
return error, stream
def __init__(self, location=None):
'''
Creates a Idl connection to the configdb and register all the columns
with schema helper.
Maintain the self global value for all the columns in configdb that
can be modified and updated to existing row or inserted as new row.
'''
self.idl = None
self.txn = None
self.schema_helper = ovs.db.idl.SchemaHelper(location=cfgdb_schema)
self.schema_helper.register_columns(
CONFIG_TABLE, [TYPE, NAME, WRITER, DATE, CONFIG, HARDWARE])
self.idl = ovs.db.idl.Idl(def_db, self.schema_helper)
self.config = None
self.type = "startup"
self.name = None
self.writer = None
self.date = None
self.hardware = None
curr_seqno = self.idl.change_seqno
while True:
self.idl.run()
if curr_seqno != self.idl.change_seqno:
break
poller = ovs.poller.Poller()
self.idl.wait(poller)
poller.block()
def open_block(error_stream):
"""Blocks until a Stream completes its connection attempt, either
succeeding or failing. (error, stream) should be the tuple returned by
Stream.open(). Returns a tuple of the same form.
Typical usage:
error, stream = Stream.open_block(Stream.open("unix:/tmp/socket"))"""
# Py3 doesn't support tuple parameter unpacking - PEP 3113
error, stream = error_stream
if not error:
while True:
error = stream.connect()
if error != errno.EAGAIN:
break
stream.run()
poller = ovs.poller.Poller()
stream.run_wait(poller)
stream.connect_wait(poller)
poller.block()
assert error != errno.EINPROGRESS
if error and stream:
stream.close()
stream = None
return error, stream
def main():
global exiting
global idl
global seqno
parser = argparse.ArgumentParser()
parser.add_argument('-d', '--database', metavar="DATABASE",
help="A socket on which ovsdb-server is listening.",
dest='database')
ovs.vlog.add_args(parser)
ovs.daemon.add_args(parser)
args = parser.parse_args()
ovs.vlog.handle_args(args)
ovs.daemon.handle_args(args)
if args.database is None:
remote = def_db
else:
remote = args.database
supportability_init(remote)
ovs.daemon.daemonize()
ovs.unixctl.command_register("exit", "", 0, 0, unixctl_exit, None)
error, unixctl_server = ovs.unixctl.server.UnixctlServer.create(None)
if error:
ovs.util.ovs_fatal(error, "could not create unix-ctl server", vlog)
# Sequence number when we last processed the db.
seqno = idl.change_seqno
exiting = False
while not exiting:
supportability_run()
unixctl_server.run()
supportability_wait()
crashprocessing_run()
if exiting:
break
if seqno == idl.change_seqno:
poller = ovs.poller.Poller()
unixctl_server.wait(poller)
idl.wait(poller)
crashprocessing_poll(poller)
poller.block()
# Daemon Exit.
unixctl_server.close()
idl.close()
def show_config(args):
ret = True
if (args[0] != "startup-config"):
print("Unknown config \"%s\" (Use --help for help)" % args[0])
return False
cfg = cfgdb.Cfgdb()
#OPS TODO: To get confg type from user as args
row, tbl_found = cfg.find_row_by_type("startup")
if tbl_found:
try:
data = json.loads(base64.b64decode(row.config))
print("Startup configuration:")
if (args[1] == "json"):
print json.dumps(data, indent=4, sort_keys=True)
elif (args[1] == "cli"):
# Here we copy saved configuration from config DB to temporary
# DB and the current startup configuration command displays
# output by traversing the temporary DB.
extschema = restparser.parseSchema(settings.get('ext_schema'))
ovsschema = settings.get('ovs_schema')
ovsremote = TEMPORARY_DB_SHOW_STARTUP
# initialize idl
opsidl = ops.dc.register(extschema, ovsschema, ovsremote)
curr_seqno = opsidl.change_seqno
while True:
opsidl.run()
if curr_seqno != opsidl.change_seqno:
break
poller = ovs.poller.Poller()
opsidl.wait(poller)
poller.block()
# write to db
result = ops.dc.write(data, extschema, opsidl)
error = None
if isinstance(result, tuple):
error = result[1]
result = result[0]
else:
error = result
if result not in [
ovs.db.idl.Transaction.SUCCESS,
ovs.db.idl.Transaction.UNCHANGED
]:
print "Transaction result %s" % result
print "Transaction result %s" % error
return False
except ValueError, e:
print("Invalid json from configdb. Exception: %s\n" % e)
ret = False
def do_listen(name):
if sys.platform != 'win32' or (
ovs.daemon._detach and ovs.daemon._detached):
# On Windows the child is a new process created which should be the
# one that creates the PassiveStream. Without this check, the new
# child process will create a new PassiveStream overwriting the one
# that the parent process created.
error, pstream = ovs.stream.PassiveStream.open(name)
if error:
sys.stderr.write("could not listen on \"%s\": %s\n"
% (name, os.strerror(error)))
sys.exit(1)
ovs.daemon.daemonize()
rpcs = []
done = False
while True:
# Accept new connections.
error, stream = pstream.accept()
if stream:
rpcs.append(ovs.jsonrpc.Connection(stream))
elif error != errno.EAGAIN:
sys.stderr.write("PassiveStream.accept() failed\n")
sys.exit(1)
# Service existing connections.
dead_rpcs = []
for rpc in rpcs:
rpc.run()
error = 0
if not rpc.get_backlog():
error, msg = rpc.recv()
if not error:
if handle_rpc(rpc, msg):
done = True
error = rpc.get_status()
if error:
rpc.close()
dead_rpcs.append(rpc)
rpcs = [rpc for rpc in rpcs if rpc not in dead_rpcs]
if done and not rpcs:
break
poller = ovs.poller.Poller()
pstream.wait(poller)
for rpc in rpcs:
rpc.wait(poller)
if not rpc.get_backlog():
rpc.recv_wait(poller)
poller.block()
pstream.close()
def do_listen(name):
if sys.platform != 'win32' or (ovs.daemon._detach
and ovs.daemon._detached):
# On Windows the child is a new process created which should be the
# one that creates the PassiveStream. Without this check, the new
# child process will create a new PassiveStream overwriting the one
# that the parent process created.
error, pstream = ovs.stream.PassiveStream.open(name)
if error:
sys.stderr.write("could not listen on \"%s\": %s\n" %
(name, os.strerror(error)))
sys.exit(1)
ovs.daemon.daemonize()
rpcs = []
done = False
while True:
# Accept new connections.
error, stream = pstream.accept()
if stream:
rpcs.append(ovs.jsonrpc.Connection(stream))
elif error != errno.EAGAIN:
sys.stderr.write("PassiveStream.accept() failed\n")
sys.exit(1)
# Service existing connections.
dead_rpcs = []
for rpc in rpcs:
rpc.run()
error = 0
if not rpc.get_backlog():
error, msg = rpc.recv()
if not error:
if handle_rpc(rpc, msg):
done = True
error = rpc.get_status()
if error:
rpc.close()
dead_rpcs.append(rpc)
rpcs = [rpc for rpc in rpcs if rpc not in dead_rpcs]
if done and not rpcs:
break
poller = ovs.poller.Poller()
pstream.wait(poller)
for rpc in rpcs:
rpc.wait(poller)
if not rpc.get_backlog():
rpc.recv_wait(poller)
poller.block()
pstream.close()
def commit_block(self):
while True:
status = self.commit()
if status != Transaction.INCOMPLETE:
return status
self.idl.run()
poller = ovs.poller.Poller()
self.idl.wait(poller)
self.wait(poller)
poller.block()
def recv_block(self):
while True:
error, msg = self.recv()
if error != errno.EAGAIN:
return error, msg
self.run()
poller = ovs.poller.Poller()
self.wait(poller)
self.recv_wait(poller)
poller.block()
def recv_block(self):
while True:
error, msg = self.recv()
if error != errno.EAGAIN:
return error, msg
self.run()
poller = ovs.poller.Poller()
self.wait(poller)
self.recv_wait(poller)
poller.block()
def commit_block(self):
while True:
status = self.commit()
if status != Transaction.INCOMPLETE:
return status
self.idl.run()
poller = ovs.poller.Poller()
self.idl.wait(poller)
self.wait(poller)
poller.block()
def send_block(self, msg):
error = self.send(msg)
if error:
return error
while True:
self.run()
if not self.get_backlog() or self.get_status():
return self.status
poller = ovs.poller.Poller()
self.wait(poller)
poller.block()
def send_block(self, msg):
error = self.send(msg)
if error:
return error
while True:
self.run()
if not self.get_backlog() or self.get_status():
return self.status
poller = ovs.poller.Poller()
self.wait(poller)
poller.block()
def do_listen(name):
ovs.daemon.die_if_already_running()
error, pstream = ovs.stream.PassiveStream.open(name)
if error:
sys.stderr.write("could not listen on \"%s\": %s\n" %
(name, os.strerror(error)))
sys.exit(1)
ovs.daemon.daemonize()
rpcs = []
done = False
while True:
# Accept new connections.
error, stream = pstream.accept()
if stream:
rpcs.append(ovs.jsonrpc.Connection(stream))
elif error != errno.EAGAIN:
sys.stderr.write("PassiveStream.accept() failed\n")
sys.exit(1)
# Service existing connections.
dead_rpcs = []
for rpc in rpcs:
rpc.run()
error = 0
if not rpc.get_backlog():
error, msg = rpc.recv()
if not error:
if handle_rpc(rpc, msg):
done = True
error = rpc.get_status()
if error:
rpc.close()
dead_rpcs.append(rpc)
rpcs = [rpc for rpc in rpcs if not rpc in dead_rpcs]
if done and not rpcs:
break
poller = ovs.poller.Poller()
pstream.wait(poller)
for rpc in rpcs:
rpc.wait(poller)
if not rpc.get_backlog():
rpc.recv_wait(poller)
poller.block()
pstream.close()
def do_listen(name):
ovs.daemon.die_if_already_running()
error, pstream = ovs.stream.PassiveStream.open(name)
if error:
sys.stderr.write("could not listen on \"%s\": %s\n"
% (name, os.strerror(error)))
sys.exit(1)
ovs.daemon.daemonize()
rpcs = []
done = False
while True:
# Accept new connections.
error, stream = pstream.accept()
if stream:
rpcs.append(ovs.jsonrpc.Connection(stream))
elif error != errno.EAGAIN:
sys.stderr.write("PassiveStream.accept() failed\n")
sys.exit(1)
# Service existing connections.
dead_rpcs = []
for rpc in rpcs:
rpc.run()
error = 0
if not rpc.get_backlog():
error, msg = rpc.recv()
if not error:
if handle_rpc(rpc, msg):
done = True
error = rpc.get_status()
if error:
rpc.close()
dead_rpcs.append(rpc)
rpcs = [rpc for rpc in rpcs if not rpc in dead_rpcs]
if done and not rpcs:
break
poller = ovs.poller.Poller()
pstream.wait(poller)
for rpc in rpcs:
rpc.wait(poller)
if not rpc.get_backlog():
rpc.recv_wait(poller)
poller.block()
pstream.close()
def get_opsidl():
extschema = restparser.parseSchema(settings.get('ext_schema'))
ovsschema = settings.get('ovs_schema')
ovsremote = settings.get('ovs_remote')
opsidl = ops.dc.register(extschema, ovsschema, ovsremote)
init_seqno = opsidl.change_seqno
while True:
opsidl.run()
if init_seqno != opsidl.change_seqno:
break
poller = ovs.poller.Poller()
opsidl.wait(poller)
poller.block()
return (extschema, opsidl)
def get_opsidl():
extschema = restparser.parseSchema(settings.get('ext_schema'))
ovsschema = settings.get('ovs_schema')
ovsremote = settings.get('ovs_remote')
opsidl = ops.dc.register(extschema, ovsschema, ovsremote)
init_seqno = opsidl.change_seqno
while True:
opsidl.run()
if init_seqno != opsidl.change_seqno:
break
poller = ovs.poller.Poller()
opsidl.wait(poller)
poller.block()
return (extschema, opsidl)
def connect():
ovsschema = settings.get('cfg_db_schema')
ovsremote = settings.get('ovs_remote')
schema_helper = SchemaHelper(ovsschema)
schema_helper.register_all()
idl = Idl(ovsremote, schema_helper)
change_seqno = idl.change_seqno
while True:
idl.run()
if change_seqno != idl.change_seqno:
break
poller = ovs.poller.Poller()
idl.wait(poller)
poller.block()
return idl
def open_block(error_stream, timeout=None):
"""Blocks until a Stream completes its connection attempt, either
succeeding or failing, but no more than 'timeout' milliseconds.
(error, stream) should be the tuple returned by Stream.open().
Negative value of 'timeout' means infinite waiting.
Returns a tuple of the same form.
Typical usage:
error, stream = Stream.open_block(Stream.open("unix:/tmp/socket"))"""
# Py3 doesn't support tuple parameter unpacking - PEP 3113
error, stream = error_stream
if not error:
deadline = None
if timeout is not None and timeout >= 0:
deadline = ovs.timeval.msec() + timeout
while True:
error = stream.connect()
if sys.platform == 'win32' and error == errno.WSAEWOULDBLOCK:
# WSAEWOULDBLOCK would be the equivalent on Windows
# for EAGAIN on Unix.
error = errno.EAGAIN
if error != errno.EAGAIN:
break
if deadline is not None and ovs.timeval.msec() > deadline:
error = errno.ETIMEDOUT
break
stream.run()
poller = ovs.poller.Poller()
stream.run_wait(poller)
stream.connect_wait(poller)
if deadline is not None:
poller.timer_wait_until(deadline)
poller.block()
if stream.socket is not None:
assert error != errno.EINPROGRESS
if error and stream:
stream.close()
stream = None
return error, stream
def open_block(error_stream, timeout=None):
"""Blocks until a Stream completes its connection attempt, either
succeeding or failing, but no more than 'timeout' milliseconds.
(error, stream) should be the tuple returned by Stream.open().
Negative value of 'timeout' means infinite waiting.
Returns a tuple of the same form.
Typical usage:
error, stream = Stream.open_block(Stream.open("unix:/tmp/socket"))"""
# Py3 doesn't support tuple parameter unpacking - PEP 3113
error, stream = error_stream
if not error:
deadline = None
if timeout is not None and timeout >= 0:
deadline = ovs.timeval.msec() + timeout
while True:
error = stream.connect()
if sys.platform == 'win32' and error == errno.WSAEWOULDBLOCK:
# WSAEWOULDBLOCK would be the equivalent on Windows
# for EAGAIN on Unix.
error = errno.EAGAIN
if error != errno.EAGAIN:
break
if deadline is not None and ovs.timeval.msec() > deadline:
error = errno.ETIMEDOUT
break
stream.run()
poller = ovs.poller.Poller()
stream.run_wait(poller)
stream.connect_wait(poller)
if deadline is not None:
poller.timer_wait_until(deadline)
poller.block()
if stream.socket is not None:
assert error != errno.EINPROGRESS
if error and stream:
stream.close()
stream = None
return error, stream
def copy_running_startup():
# get running config
extschema = restparser.parseSchema(settings.get('ext_schema'))
ovsschema = settings.get('ovs_schema')
ovsremote = settings.get('ovs_remote')
print "Copy in progress ...."
# initialize idl
opsidl = ops.dc.register(extschema, ovsschema, ovsremote)
curr_seqno = opsidl.change_seqno
while True:
opsidl.run()
if curr_seqno != opsidl.change_seqno:
break
poller = ovs.poller.Poller()
opsidl.wait(poller)
poller.block()
try:
running_config = ops.dc.read(extschema, opsidl)
except:
print "ERROR: Copy failed"
return False
# base64 encode to save as startup
config = base64.b64encode(json.dumps(running_config))
cfg = cfgdb.Cfgdb()
cfg.config = config
cfg.type = "startup"
row, tbl_found = cfg.find_row_by_type("startup")
if tbl_found:
cfg.update_row(row)
else:
cfg.insert_row()
cfg.close()
print "Success"
return True
def do_idl(schema_file, remote, *commands):
schema_helper = ovs.db.idl.SchemaHelper(schema_file)
schema_helper.register_all()
idl = ovs.db.idl.Idl(remote, schema_helper)
if commands:
error, stream = ovs.stream.Stream.open_block(
ovs.stream.Stream.open(remote))
if error:
sys.stderr.write("failed to connect to \"%s\"" % remote)
sys.exit(1)
rpc = ovs.jsonrpc.Connection(stream)
else:
rpc = None
symtab = {}
seqno = 0
step = 0
for command in commands:
if command.startswith("+"):
# The previous transaction didn't change anything.
command = command[1:]
else:
# Wait for update.
while idl.change_seqno == seqno and not idl.run():
rpc.run()
poller = ovs.poller.Poller()
idl.wait(poller)
rpc.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
seqno = idl.change_seqno
if command == "reconnect":
print("%03d: reconnect" % step)
sys.stdout.flush()
step += 1
idl.force_reconnect()
elif not command.startswith("["):
idl_set(idl, command, step)
step += 1
else:
json = ovs.json.from_string(command)
if type(json) in [str, unicode]:
sys.stderr.write("\"%s\": %s\n" % (command, json))
sys.exit(1)
json = substitute_uuids(json, symtab)
request = ovs.jsonrpc.Message.create_request("transact", json)
error, reply = rpc.transact_block(request)
if error:
sys.stderr.write("jsonrpc transaction failed: %s" %
os.strerror(error))
sys.exit(1)
elif reply.error is not None:
sys.stderr.write("jsonrpc transaction failed: %s" %
reply.error)
sys.exit(1)
sys.stdout.write("%03d: " % step)
sys.stdout.flush()
step += 1
if reply.result is not None:
parse_uuids(reply.result, symtab)
reply.id = None
sys.stdout.write("%s\n" % ovs.json.to_string(reply.to_json()))
sys.stdout.flush()
if rpc:
rpc.close()
while idl.change_seqno == seqno and not idl.run():
poller = ovs.poller.Poller()
idl.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
idl.close()
print("%03d: done" % step)
def do_idl(schema_file, remote, *commands):
schema_helper = ovs.db.idl.SchemaHelper(schema_file)
if commands and commands[0].startswith("?"):
readonly = {}
for x in commands[0][1:].split("?"):
readonly = []
table, columns = x.split(":")
columns = columns.split(",")
for index, column in enumerate(columns):
if column[-1] == '!':
columns[index] = columns[index][:-1]
readonly.append(columns[index])
schema_helper.register_columns(table, columns, readonly)
commands = commands[1:]
else:
schema_helper.register_all()
idl = ovs.db.idl.Idl(remote, schema_helper)
if commands:
error, stream = ovs.stream.Stream.open_block(
ovs.stream.Stream.open(remote))
if error:
sys.stderr.write("failed to connect to \"%s\"" % remote)
sys.exit(1)
rpc = ovs.jsonrpc.Connection(stream)
else:
rpc = None
symtab = {}
seqno = 0
step = 0
for command in commands:
if command.startswith("+"):
# The previous transaction didn't change anything.
command = command[1:]
else:
# Wait for update.
while idl.change_seqno == seqno and not idl.run():
rpc.run()
poller = ovs.poller.Poller()
idl.wait(poller)
rpc.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
seqno = idl.change_seqno
if command == "reconnect":
print("%03d: reconnect" % step)
sys.stdout.flush()
step += 1
idl.force_reconnect()
elif not command.startswith("["):
idl_set(idl, command, step)
step += 1
else:
json = ovs.json.from_string(command)
if isinstance(json, six.string_types):
sys.stderr.write("\"%s\": %s\n" % (command, json))
sys.exit(1)
json = substitute_uuids(json, symtab)
request = ovs.jsonrpc.Message.create_request("transact", json)
error, reply = rpc.transact_block(request)
if error:
sys.stderr.write("jsonrpc transaction failed: %s"
% os.strerror(error))
sys.exit(1)
elif reply.error is not None:
sys.stderr.write("jsonrpc transaction failed: %s"
% reply.error)
sys.exit(1)
sys.stdout.write("%03d: " % step)
sys.stdout.flush()
step += 1
if reply.result is not None:
parse_uuids(reply.result, symtab)
reply.id = None
sys.stdout.write("%s\n" % ovs.json.to_string(reply.to_json()))
sys.stdout.flush()
if rpc:
rpc.close()
while idl.change_seqno == seqno and not idl.run():
poller = ovs.poller.Poller()
idl.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
idl.close()
print("%03d: done" % step)
def do_idl(schema_file, remote, *commands):
schema_helper = ovs.db.idl.SchemaHelper(schema_file)
if commands and commands[0].startswith("?"):
readonly = {}
for x in commands[0][1:].split("?"):
readonly = []
table, columns = x.split(":")
columns = columns.split(",")
for index, column in enumerate(columns):
if column[-1] == '!':
columns[index] = columns[index][:-1]
readonly.append(columns[index])
schema_helper.register_columns(table, columns, readonly)
commands = commands[1:]
else:
schema_helper.register_all()
idl = ovs.db.idl.Idl(remote, schema_helper)
if commands:
error, stream = ovs.stream.Stream.open_block(
ovs.stream.Stream.open(remote))
if error:
sys.stderr.write("failed to connect to \"%s\"" % remote)
sys.exit(1)
rpc = ovs.jsonrpc.Connection(stream)
else:
rpc = None
symtab = {}
seqno = 0
step = 0
commands = list(commands)
if len(commands) >= 1 and "condition" in commands[0]:
update_condition(idl, commands.pop(0))
sys.stdout.write("%03d: change conditions\n" % step)
sys.stdout.flush()
step += 1
for command in commands:
if command.startswith("+"):
# The previous transaction didn't change anything.
command = command[1:]
else:
# Wait for update.
while idl.change_seqno == seqno and not idl.run():
rpc.run()
poller = ovs.poller.Poller()
idl.wait(poller)
rpc.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
seqno = idl.change_seqno
if command == "reconnect":
print("%03d: reconnect" % step)
sys.stdout.flush()
step += 1
idl.force_reconnect()
elif "condition" in command:
update_condition(idl, command)
sys.stdout.write("%03d: change conditions\n" % step)
sys.stdout.flush()
step += 1
elif not command.startswith("["):
idl_set(idl, command, step)
step += 1
else:
json = ovs.json.from_string(command)
if isinstance(json, six.string_types):
sys.stderr.write("\"%s\": %s\n" % (command, json))
sys.exit(1)
json = substitute_uuids(json, symtab)
request = ovs.jsonrpc.Message.create_request("transact", json)
error, reply = rpc.transact_block(request)
if error:
sys.stderr.write("jsonrpc transaction failed: %s"
% os.strerror(error))
sys.exit(1)
elif reply.error is not None:
sys.stderr.write("jsonrpc transaction failed: %s"
% reply.error)
sys.exit(1)
sys.stdout.write("%03d: " % step)
sys.stdout.flush()
step += 1
if reply.result is not None:
parse_uuids(reply.result, symtab)
reply.id = None
sys.stdout.write("%s\n" % ovs.json.to_string(reply.to_json()))
sys.stdout.flush()
if rpc:
rpc.close()
while idl.change_seqno == seqno and not idl.run():
poller = ovs.poller.Poller()
idl.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
idl.close()
print("%03d: done" % step)
def do_idl_cluster(schema_file, remote, pid, *commands):
schema_helper = ovs.db.idl.SchemaHelper(schema_file)
if remote.startswith("ssl:"):
if len(commands) < 3:
sys.stderr.write("SSL connection requires private key, "
"certificate for private key, and peer CA "
"certificate as arguments\n")
sys.exit(1)
ovs.stream.Stream.ssl_set_private_key_file(commands[0])
ovs.stream.Stream.ssl_set_certificate_file(commands[1])
ovs.stream.Stream.ssl_set_ca_cert_file(commands[2])
commands = commands[3:]
schema_helper.register_all()
idl = ovs.db.idl.Idl(remote, schema_helper)
step = 0
seqno = 0
commands = list(commands)
for command in commands:
if command.startswith("+"):
# The previous transaction didn't change anything.
command = command[1:]
else:
# Wait for update.
while idl.change_seqno == seqno and not idl.run():
poller = ovs.poller.Poller()
idl.wait(poller)
poller.block()
step += 1
seqno = idl.change_seqno
if command == "reconnect":
print("%03d: reconnect" % step)
sys.stdout.flush()
step += 1
idl.force_reconnect()
elif command == "remote":
print("%03d: %s" % (step, idl.session_name()))
sys.stdout.flush()
step += 1
elif command == "remotestop":
r = idl.session_name()
remotes = remote.split(',')
i = remotes.index(r)
pids = pid.split(',')
command = None
try:
command = "kill %s" % pids[i]
except ValueError as error:
sys.stderr.write("Cannot find pid of remote: %s\n"
% os.strerror(error))
sys.exit(1)
os.popen(command)
print("%03d: stop %s" % (step, pids[i]))
sys.stdout.flush()
step += 1
idl.close()
print("%03d: done" % step)
def do_idl(schema_file, remote, *commands):
schema_helper = ovs.db.idl.SchemaHelper(schema_file)
track_notify = False
if remote.startswith("ssl:"):
ovs.stream.Stream.ssl_set_private_key_file(commands[0])
ovs.stream.Stream.ssl_set_certificate_file(commands[1])
ovs.stream.Stream.ssl_set_ca_cert_file(commands[2])
commands = commands[3:]
if commands and commands[0] == "track-notify":
commands = commands[1:]
track_notify = True
if commands and commands[0].startswith("?"):
readonly = {}
for x in commands[0][1:].split("?"):
readonly = []
table, columns = x.split(":")
columns = columns.split(",")
for index, column in enumerate(columns):
if column[-1] == '!':
columns[index] = columns[index][:-1]
readonly.append(columns[index])
schema_helper.register_columns(table, columns, readonly)
commands = commands[1:]
else:
schema_helper.register_all()
idl = ovs.db.idl.Idl(remote, schema_helper)
if commands:
error, stream = ovs.stream.Stream.open_block(
ovs.stream.Stream.open(remote))
if error:
sys.stderr.write("failed to connect to \"%s\"" % remote)
sys.exit(1)
rpc = ovs.jsonrpc.Connection(stream)
else:
rpc = None
symtab = {}
seqno = 0
step = 0
def mock_notify(event, row, updates=None):
output = "%03d: " % step
output += "event:" + str(event) + ", row={"
output += get_simple_table_printable_row(row) + "}, updates="
if updates is None:
output += "None"
else:
output += "{" + get_simple_table_printable_row(updates) + "}"
output += '\n'
sys.stdout.write(output)
sys.stdout.flush()
if track_notify and "simple" in idl.tables:
idl.notify = mock_notify
commands = list(commands)
if len(commands) >= 1 and "condition" in commands[0]:
update_condition(idl, commands.pop(0))
sys.stdout.write("%03d: change conditions\n" % step)
sys.stdout.flush()
step += 1
for command in commands:
if command.startswith("+"):
# The previous transaction didn't change anything.
command = command[1:]
else:
# Wait for update.
while idl.change_seqno == seqno and not idl.run():
rpc.run()
poller = ovs.poller.Poller()
idl.wait(poller)
rpc.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
seqno = idl.change_seqno
if command == "reconnect":
print("%03d: reconnect" % step)
sys.stdout.flush()
step += 1
idl.force_reconnect()
elif "condition" in command:
update_condition(idl, command)
sys.stdout.write("%03d: change conditions\n" % step)
sys.stdout.flush()
step += 1
elif not command.startswith("["):
idl_set(idl, command, step)
step += 1
else:
json = ovs.json.from_string(command)
if isinstance(json, six.string_types):
sys.stderr.write("\"%s\": %s\n" % (command, json))
sys.exit(1)
json = substitute_uuids(json, symtab)
request = ovs.jsonrpc.Message.create_request("transact", json)
error, reply = rpc.transact_block(request)
if error:
sys.stderr.write("jsonrpc transaction failed: %s"
% os.strerror(error))
sys.exit(1)
elif reply.error is not None:
sys.stderr.write("jsonrpc transaction failed: %s"
% reply.error)
sys.exit(1)
sys.stdout.write("%03d: " % step)
sys.stdout.flush()
step += 1
if reply.result is not None:
parse_uuids(reply.result, symtab)
reply.id = None
sys.stdout.write("%s\n" % ovs.json.to_string(reply.to_json()))
sys.stdout.flush()
if rpc:
rpc.close()
while idl.change_seqno == seqno and not idl.run():
poller = ovs.poller.Poller()
idl.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
idl.close()
print("%03d: done" % step)
print "Copy in progress ...."
extschema = restparser.parseSchema(settings.get('ext_schema'))
ovsschema = settings.get('ovs_schema')
ovsremote = settings.get('ovs_remote')
# initialize idl
opsidl = ops.dc.register(extschema, ovsschema, ovsremote)
curr_seqno = opsidl.change_seqno
while True:
opsidl.run()
if curr_seqno != opsidl.change_seqno:
break
poller = ovs.poller.Poller()
opsidl.wait(poller)
poller.block()
result = ops.dc.write(data, extschema, opsidl)
error = None
if isinstance(result, tuple):
error = result[1]
result = result[0]
else:
error = result
if result not in [
ovs.db.idl.Transaction.SUCCESS, ovs.db.idl.Transaction.UNCHANGED
]:
print "ERROR: Copy failed"
return False
def do_idl(schema_file, remote, *commands):
schema_helper = ovs.db.idl.SchemaHelper(schema_file)
track_notify = False
if remote.startswith("ssl:"):
if len(commands) < 3:
sys.stderr.write("SSL connection requires private key, "
"certificate for private key, and peer CA "
"certificate as arguments\n")
sys.exit(1)
ovs.stream.Stream.ssl_set_private_key_file(commands[0])
ovs.stream.Stream.ssl_set_certificate_file(commands[1])
ovs.stream.Stream.ssl_set_ca_cert_file(commands[2])
commands = commands[3:]
if commands and commands[0] == "track-notify":
commands = commands[1:]
track_notify = True
if commands and commands[0].startswith("?"):
readonly = {}
for x in commands[0][1:].split("?"):
readonly = []
table, columns = x.split(":")
columns = columns.split(",")
for index, column in enumerate(columns):
if column[-1] == '!':
columns[index] = columns[index][:-1]
readonly.append(columns[index])
schema_helper.register_columns(table, columns, readonly)
commands = commands[1:]
else:
schema_helper.register_all()
idl = ovs.db.idl.Idl(remote, schema_helper)
if "simple3" in idl.tables:
idl.index_create("simple3", "simple3_by_name")
if commands:
remotes = remote.split(',')
stream = None
for r in remotes:
error, stream = ovs.stream.Stream.open_block(
ovs.stream.Stream.open(r))
if not error and stream:
break
stream = None
if not stream:
sys.stderr.write("failed to connect to \"%s\"" % remote)
sys.exit(1)
rpc = ovs.jsonrpc.Connection(stream)
else:
rpc = None
symtab = {}
seqno = 0
step = 0
def mock_notify(event, row, updates=None):
output = "%03d: " % step
output += "event:" + str(event) + ", row={"
output += get_simple_table_printable_row(row) + "}, updates="
if updates is None:
output += "None"
else:
output += "{" + get_simple_table_printable_row(updates) + "}"
output += '\n'
sys.stdout.write(output)
sys.stdout.flush()
if track_notify and "simple" in idl.tables:
idl.notify = mock_notify
commands = list(commands)
if len(commands) >= 1 and "condition" in commands[0]:
update_condition(idl, commands.pop(0))
sys.stdout.write("%03d: change conditions\n" % step)
sys.stdout.flush()
step += 1
for command in commands:
if command.startswith("+"):
# The previous transaction didn't change anything.
command = command[1:]
else:
# Wait for update.
while idl.change_seqno == seqno and not idl.run():
rpc.run()
poller = ovs.poller.Poller()
idl.wait(poller)
rpc.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
seqno = idl.change_seqno
if command == "reconnect":
print("%03d: reconnect" % step)
sys.stdout.flush()
step += 1
idl.force_reconnect()
elif "condition" in command:
update_condition(idl, command)
sys.stdout.write("%03d: change conditions\n" % step)
sys.stdout.flush()
step += 1
elif not command.startswith("["):
idl_set(idl, command, step)
step += 1
else:
json = ovs.json.from_string(command)
if isinstance(json, six.string_types):
sys.stderr.write("\"%s\": %s\n" % (command, json))
sys.exit(1)
json = substitute_uuids(json, symtab)
request = ovs.jsonrpc.Message.create_request("transact", json)
error, reply = rpc.transact_block(request)
if error:
sys.stderr.write("jsonrpc transaction failed: %s\n" %
os.strerror(error))
sys.exit(1)
elif reply.error is not None:
sys.stderr.write("jsonrpc transaction failed: %s\n" %
reply.error)
sys.exit(1)
sys.stdout.write("%03d: " % step)
sys.stdout.flush()
step += 1
if reply.result is not None:
parse_uuids(reply.result, symtab)
reply.id = None
sys.stdout.write("%s\n" % ovs.json.to_string(reply.to_json()))
sys.stdout.flush()
if rpc:
rpc.close()
while idl.change_seqno == seqno and not idl.run():
poller = ovs.poller.Poller()
idl.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
idl.close()
print("%03d: done" % step)
def do_idl(schema_file, remote, *commands):
schema = ovs.db.schema.DbSchema.from_json(ovs.json.from_file(schema_file))
idl = ovs.db.idl.Idl(remote, schema)
if commands:
error, stream = ovs.stream.Stream.open_block(
ovs.stream.Stream.open(remote))
if error:
sys.stderr.write("failed to connect to \"%s\"" % remote)
sys.exit(1)
rpc = ovs.jsonrpc.Connection(stream)
else:
rpc = None
symtab = {}
seqno = 0
step = 0
for command in commands:
if command.startswith("+"):
# The previous transaction didn't change anything.
command = command[1:]
else:
# Wait for update.
while idl.change_seqno == seqno and not idl.run():
rpc.run()
poller = ovs.poller.Poller()
idl.wait(poller)
rpc.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
seqno = idl.change_seqno
if command == "reconnect":
print("%03d: reconnect" % step)
sys.stdout.flush()
step += 1
idl.force_reconnect()
elif not command.startswith("["):
idl_set(idl, command, step)
step += 1
else:
json = ovs.json.from_string(command)
if type(json) in [str, unicode]:
sys.stderr.write("\"%s\": %s\n" % (command, json))
sys.exit(1)
json = substitute_uuids(json, symtab)
request = ovs.jsonrpc.Message.create_request("transact", json)
error, reply = rpc.transact_block(request)
if error:
sys.stderr.write("jsonrpc transaction failed: %s"
% os.strerror(error))
sys.exit(1)
sys.stdout.write("%03d: " % step)
sys.stdout.flush()
step += 1
if reply.result is not None:
parse_uuids(reply.result, symtab)
reply.id = None
sys.stdout.write("%s\n" % ovs.json.to_string(reply.to_json()))
sys.stdout.flush()
if rpc:
rpc.close()
while idl.change_seqno == seqno and not idl.run():
poller = ovs.poller.Poller()
idl.wait(poller)
poller.block()
print_idl(idl, step)
step += 1
idl.close()
print("%03d: done" % step)
