def onOpen(self):
print("WebSocket connection open.")
# create a fabric port
node = Node("PORT_TEST", "host-test",
metadata={"Name": "Test port !", "Type": "fabric"})
msg = WSMessage("Graph", NodeAddedMsgType, node)
self.sendWSMessage(msg)
# get the TOR id
restclient = RESTClient("localhost:8082")
nodes = restclient.lookup_nodes("G.V().Has('Name', 'TOR2')")
if len(nodes) != 1:
print("More than one node found")
sys.exit(-1)
tor_id = nodes[0].id
# create a ownership + layer2 link
edge = Edge(tor_id + node.id + "ownership", "host-test",
tor_id, node.id,
metadata={"RelationType": "ownership"})
msg = WSMessage("Graph", EdgeAddedMsgType, edge)
self.sendWSMessage(msg)
edge = Edge(tor_id + node.id + "layer2", "",
tor_id, node.id,
metadata={"RelationType": "layer2", "Type": "fabric"})
msg = WSMessage("Graph", EdgeAddedMsgType, edge)
self.sendWSMessage(msg)
print("Success!")
self.sendClose()
def run(self):
logging.info("thread threadGetSkydiveFlows starttime %d",
int(time.time() * 1000.0))
err = ""
restclient = RESTClient(SKYDIVE_IP + ":" + SKYDIVE_PORT)
gremlinFlow = "G.Flows().Has('Application', 'TCP')"
flows = restclient.lookup(gremlinFlow)
dfOldFlows = json_normalize(flows)
frames = []
time_out = time.time() + TIME_OUT
while (self.collectFlows) & (time.time() < time_out):
flows = restclient.lookup(gremlinFlow)
df = json_normalize(flows)
if (not df.empty) & (not dfOldFlows.empty):
cond = df['UUID'].isin(dfOldFlows['UUID']) == True
df.drop(df[cond].index, inplace=True)
if not df.empty:
frames.append(df)
sleep(1)
if time.time() >= time_out:
err = "Error: skydive time out"
logging.info(err)
df = pd.DataFrame()
if len(frames) > 0:
df = pd.concat(frames, sort=False)
df = df.drop_duplicates()
df = df.sort_values("Metric.Last", ascending=True)
df = df.drop_duplicates(subset="UUID", keep='last')
self._return = (df, err)
def onOpen(self):
print("WebSocket connection open.")
# create a fabric port
node = Node("PORT_TEST", "host-test",
metadata={"Name": "Test port !", "Type": "fabric"})
msg = WSMessage("Graph", NodeAddedMsgType, node)
self.sendWSMessage(msg)
# get the TOR id
restclient = RESTClient("localhost:8082")
nodes = restclient.lookup_nodes("G.V().Has('Name', 'TOR2')")
if len(nodes) != 1:
print("More than one node found")
sys.exit(-1)
tor_id = nodes[0].id
# create a ownership + layer2 link
edge = Edge(tor_id + node.id + "ownership", "host-test",
tor_id, node.id,
metadata={"RelationType": "ownership"})
msg = WSMessage("Graph", EdgeAddedMsgType, edge)
self.sendWSMessage(msg)
edge = Edge(tor_id + node.id + "layer2", "",
tor_id, node.id,
metadata={"RelationType": "layer2", "Type": "fabric"})
msg = WSMessage("Graph", EdgeAddedMsgType, edge)
self.sendWSMessage(msg)
print("Success!")
self.sendClose()
def test_injections(self):
restclient = RESTClient("localhost:8082",
scheme=self.schemeHTTP,
username=self.username,
password=self.password,
insecure=True)
nodes = restclient.lookup("G.V().Has('Name', 'eth0')")
testnode = nodes[0]["Metadata"]["TID"]
query = "G.V().Has('TID', '" + testnode + "')"
num_injections_before = len(restclient.injection_list())
injection_response = restclient.injection_create(query,
query,
count=1000)
num_injections_after = len(restclient.injection_list())
self.assertEqual(num_injections_after, num_injections_before + 1,
"injection creation didn't succeed")
restclient.injection_delete(injection_response.uuid)
num_injections_after_deletion = len(restclient.injection_list())
self.assertEqual(num_injections_after_deletion, num_injections_before,
"injection deletion didn't succeed")
def test_injection(self):
def create_node(protocol):
node = Node("TOR_TEST",
"",
metadata={
"Name": "Test TOR",
"Type": "fabric"
})
msg = WSMessage("Graph", NodeAddedMsgType, node)
protocol.sendWSMessage(msg)
node = Node("PORT_TEST",
"",
metadata={
"Name": "Test port",
"Type": "fabric"
})
msg = WSMessage("Graph", NodeAddedMsgType, node)
protocol.sendWSMessage(msg)
edge = Edge("TOR_L2LINK",
"",
"TOR_TEST",
"PORT_TEST",
metadata={"RelationType": "layer2"})
msg = WSMessage("Graph", EdgeAddedMsgType, edge)
protocol.sendWSMessage(msg)
self.wsclient = WSClient("host-test2",
self.schemeWS +
"://localhost:8082/ws/publisher",
protocol=WSTestClient,
test=create_node,
username=self.username,
password=self.password,
insecure=True)
self.wsclient.connect()
self.wsclient.start()
time.sleep(1)
restclient = RESTClient("localhost:8082",
scheme=self.schemeHTTP,
username=self.username,
password=self.password,
insecure=True)
nodes = restclient.lookup_nodes("G.V().Has('Name', 'Test port')")
self.assertEqual(len(nodes), 1, "should find one an only one node")
tor_id = nodes[0].id
self.assertEqual(tor_id, nodes[0].id, "wrong id for node")
edges = restclient.lookup_edges("G.E().Has('RelationType', 'layer2')")
self.assertEqual(len(edges), 1, "should find one an only one edge")
def make_query(params):
"""Performs the query with the rest client
:param params: the parameters of the ansible module implemented.
:returns: a list of nodes coded as dictionary (JSON representation
of skydive node).
"""
scheme = "https" if params["ssl"] else "http"
restclient = RESTClient(params["analyzer"],
scheme=scheme,
insecure=params["insecure"],
username=params["username"],
password=params["password"])
nodes = restclient.lookup_nodes(params["query"])
return [node.repr_json() for node in nodes]
def clear_dragonflow_items(self):
"""Delete all the items created by DragonFlow"""
restclient = RESTClient(cfg.CONF.df_skydive.analyzer_endpoint,
username=cfg.CONF.df_skydive.user,
password=cfg.CONF.df_skydive.password)
items = restclient.lookup_edges("G.E().Has('source', 'dragonflow')")
for edge in items:
edge_del_msg = skydive_client.WSMessage(
"Graph", skydive_client.EdgeDeletedMsgType, edge)
self.protocol.sendWSMessage(edge_del_msg)
items = restclient.lookup_nodes("G.V().Has('source', 'dragonflow')")
for node in items:
node_del_msg = skydive_client.WSMessage(
"Graph", skydive_client.NodeDeletedMsgType, node)
self.protocol.sendWSMessage(node_del_msg)
def __init__(self, **kwargs):
if not HAS_SKYDIVE_CLIENT:
raise Exception('skydive-client is required but does not appear '
'to be installed. It can be installed using the '
'command `pip install skydive-client`')
if not set(kwargs.keys()).issubset(SKYDIVE_PROVIDER_SPEC.keys()):
raise Exception(
'invalid or unsupported keyword argument for skydive_restclient connection.'
)
for key, value in iteritems(SKYDIVE_PROVIDER_SPEC):
if key not in kwargs:
# apply default values from SKYDIVE_PROVIDER_SPEC since we cannot just
# assume the provider values are coming from AnsibleModule
if 'default' in value:
kwargs[key] = value['default']
# override any values with env variables unless they were
# explicitly set
env = ('SKYDIVE_%s' % key).upper()
if env in os.environ:
kwargs[key] = os.environ.get(env)
kwargs['scheme'] = "http"
if 'ssl' in kwargs:
if kwargs['ssl']:
kwargs['scheme'] = "https"
if 'insecure' not in kwargs:
kwargs['insecure'] = False
self.restclient_object = RESTClient(kwargs['endpoint'],
scheme=kwargs['scheme'],
insecure=kwargs['insecure'],
username=kwargs['username'],
password=kwargs['password'])
def main():
parser=argparse.ArgumentParser()
parser.add_argument('--analyzer', type=str, required=True,
dest='analyzer',
help='address of the Skydive analyzer')
parser.add_argument('--username', type=str, default="",
dest='username',
help='client username')
parser.add_argument('--password', type=str, default="",
dest='password',
help='client password')
parser.add_argument('--ssl', default=False,
dest='ssl',
action="store_true",
help='use a secure SSL/TLS connection')
parser.add_argument('--insecure', default=False,
dest='insecure',
action="store_true",
help="insecure connection, don't verify certificate")
parser.add_argument('--use-flows', default=False,
dest='use_flows',
action="store_true",
help="leverages flows for matrix computing")
parser.add_argument('--at', type=str, default="",
dest='at',
help='gremlin time at context')
parser.add_argument('--duration', type=int, default=0,
dest='duration',
help='gremlin time duration context')
parser.add_argument('--list-no-peers', default=False,
dest='list_no_peers',
action="store_true",
help="list connection peer not found/tracked by skydive")
parser.add_argument('--format', default="csv",
dest='format', choices=['csv', 'dot', 'render', 'skydive'],
help="specify the output format")
parser.add_argument('--engine', default="dot",
dest='engine', choices=['dot', 'circo', 'neato'],
help="specify the rendering engine")
args=parser.parse_args()
scheme="http"
if args.ssl:
scheme="https"
restclient=RESTClient(args.analyzer, scheme=scheme, insecure=args.insecure,
username=args.username, password=args.password)
matrix=Matrix(restclient, args.use_flows, args.at, args.duration)
if args.format == "dot" or args.format == "render":
dot_output(matrix, args.engine, args.format == "render")
elif args.format == "skydive":
skydive_output(matrix)
else:
csv_output(matrix, args.list_no_peers)
def new_rest_client(self):
return RESTClient("localhost:8082",
scheme=self.schemeHTTP,
username=self.username,
password=self.password,
insecure=self.insecure,
cafile=self.cafile,
certfile=self.certfile,
keyfile=self.keyfile)
def test_injection(self):
def create_node(protocol):
node = Node("TOR_TEST", "",
metadata={"Name": "Test TOR", "Type": "fabric"})
msg = WSMessage("Graph", NodeAddedMsgType, node)
protocol.sendWSMessage(msg)
node = Node("PORT_TEST", "",
metadata={"Name": "Test port", "Type": "fabric"})
msg = WSMessage("Graph", NodeAddedMsgType, node)
protocol.sendWSMessage(msg)
edge = Edge("TOR_L2LINK", "",
"TOR_TEST", "PORT_TEST",
metadata={"RelationType": "layer2"})
msg = WSMessage("Graph", EdgeAddedMsgType, edge)
protocol.sendWSMessage(msg)
self.wsclient = WSClient("host-test2",
self.schemeWS +
"://localhost:8082/ws/publisher",
protocol=WSTestClient, test=create_node,
username=self.username,
password=self.password,
insecure=True)
self.wsclient.connect()
self.wsclient.start()
time.sleep(1)
restclient = RESTClient("localhost:8082",
scheme=self.schemeHTTP,
username=self.username,
password=self.password,
insecure=True)
nodes = restclient.lookup_nodes("G.V().Has('Name', 'Test port')")
self.assertEqual(len(nodes), 1, "should find one an only one node")
tor_id = nodes[0].id
self.assertEqual(tor_id, nodes[0].id, "wrong id for node")
edges = restclient.lookup_edges(
"G.E().Has('RelationType', 'layer2')")
self.assertEqual(len(edges), 1, "should find one an only one edge")
def get_node_id(module, node_selector):
scheme = "http"
if module.params["ssl"]:
scheme = "https"
if node_selector.startswith("G.") or node_selector.startswith("g."):
restclient = RESTClient(module.params["analyzer"],
scheme=scheme,
insecure=module.params["insecure"],
username=module.params["username"],
password=module.params["password"])
nodes = restclient.lookup_nodes(node_selector)
if len(nodes) == 0:
raise Exception("Node not found: %s" % node_selector)
elif len(nodes) > 1:
raise Exception("Node selection should return only one node: %s" %
node_selector)
return str(nodes[0].id)
return node_selector
def __init__(self, **kwargs):
super(skydive_restclient, self).__init__(**kwargs)
kwargs['scheme'] = "http"
if 'ssl' in kwargs:
if kwargs['ssl']:
kwargs['scheme'] = "https"
if 'insecure' not in kwargs:
kwargs['insecure'] = False
self.restclient_object = RESTClient(kwargs['endpoint'],
scheme=kwargs['scheme'],
insecure=kwargs['insecure'],
username=kwargs['username'],
password=kwargs['password'])
def create_node(protocol):
node = Node("TOR_TEST",
"",
metadata={
"Name": "Test TOR",
"Type": "fabric"
})
msg = WSMessage("Graph", NodeAddedMsgType, node)
protocol.sendWSMessage(msg)
node = Node("PORT_TEST",
"",
metadata={
"Name": "Test port",
"Type": "fabric"
})
msg = WSMessage("Graph", NodeAddedMsgType, node)
protocol.sendWSMessage(msg)
edge = Edge("TOR_L2LINK",
"",
"TOR_TEST",
"PORT_TEST",
metadata={"RelationType": "layer2"})
msg = WSMessage("Graph", EdgeAddedMsgType, edge)
protocol.sendWSMessage(msg)
time.sleep(1)
restclient = RESTClient("localhost:8082")
nodes = restclient.lookup_nodes("G.V().Has('Name', 'Test port')")
self.assertEqual(len(nodes), 1, "should find one an only one node")
tor_id = nodes[0].id
self.assertEqual(tor_id, nodes[0].id, "wrong id for node")
edges = restclient.lookup_edges(
"G.E().Has('RelationType', 'layer2')")
self.assertEqual(len(edges), 1, "should find one an only one edge")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--analyzer',
type=str,
required=True,
dest='analyzer',
help='address of the Skydive analyzer')
parser.add_argument('--username',
type=str,
default="",
dest='username',
help='client username')
parser.add_argument('--password',
type=str,
default="",
dest='password',
help='client password')
parser.add_argument('--ssl',
default=False,
dest='ssl',
action="store_true",
help='use a secure SSL/TLS connection')
parser.add_argument('--insecure',
default=False,
dest='insecure',
action="store_true",
help="insecure connection, don't verify certificate")
parser.add_argument('--use-flows',
default=False,
dest='use_flows',
action="store_true",
help="leverages flows for matrix computing")
args = parser.parse_args()
scheme = "http"
if args.ssl:
scheme = "https"
restclient = RESTClient(args.analyzer,
scheme=scheme,
insecure=args.insecure,
username=args.username,
password=args.password)
result = matrix(restclient, args.use_flows)
print("protocol,server,server_ip,port,server_proc,server_procname,"
"client,client_ip,client_proc,client_procname")
for e in result:
print(e)
def __init__(self, **kwargs):
super(skydive_restclient, self).__init__(**kwargs)
kwargs["scheme"] = "http"
if "ssl" in kwargs:
if kwargs["ssl"]:
kwargs["scheme"] = "https"
if "insecure" not in kwargs:
kwargs["insecure"] = False
self.restclient_object = RESTClient(
kwargs["endpoint"],
scheme=kwargs["scheme"],
insecure=kwargs["insecure"],
username=kwargs["username"],
password=kwargs["password"],
)
def test_capture(self):
restclient = RESTClient("localhost:8082",
scheme=self.schemeHTTP,
username=self.username,
password=self.password,
insecure=True)
capture1 = restclient.capture_create(
"G.V().Has('Name', 'test', 'Type', 'netns')")
captures = restclient.capture_list()
self.assertGreaterEqual(len(captures), 1, "no capture found")
for capture in captures:
if (capture.uuid == capture1.uuid):
found = True
break
self.assertTrue(found, "created capture not found")
restclient.capture_delete(capture1.uuid)
def test_alert(self):
restclient = RESTClient("localhost:8082",
scheme=self.schemeHTTP,
username=self.username,
password=self.password,
insecure=True)
alert1 = restclient.alert_create(
"https://localhost:8081",
"G.V().Has('Name', 'alert-ns-webhook', 'Type', 'netns')")
alerts = restclient.alert_list()
self.assertGreaterEqual(len(alerts), 1, "no alerts found")
for alert in alerts:
if (alert.uuid == alert1.uuid):
found = True
break
self.assertTrue(found, "created alert not found")
restclient.alert_delete(alert1.uuid)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--analyzer',
type=str,
required=True,
dest='analyzer',
help='address of the Skydive analyzer')
parser.add_argument('--username',
type=str,
default="",
dest='username',
help='client username')
parser.add_argument('--password',
type=str,
default="",
dest='password',
help='client password')
parser.add_argument('--ssl',
default=False,
dest='ssl',
action="store_true",
help='use a secure SSL/TLS connection')
parser.add_argument('--insecure',
default=False,
dest='insecure',
action="store_true",
help="insecure connection, don't verify certificate")
parser.add_argument('--use-flows',
default=False,
dest='use_flows',
action="store_true",
help="leverages flows for matrix computing")
parser.add_argument('--at',
type=str,
default="",
dest='at',
help='gremlin time at context')
parser.add_argument('--duration',
type=int,
default=0,
dest='duration',
help='gremlin time duration context')
parser.add_argument(
'--list-no-peers',
default=False,
dest='list_no_peers',
action="store_true",
help="list connection peer not found/tracked by skydive")
args = parser.parse_args()
scheme = "http"
if args.ssl:
scheme = "https"
restclient = RESTClient(args.analyzer,
scheme=scheme,
insecure=args.insecure,
username=args.username,
password=args.password)
matrix = Matrix(restclient, args.use_flows, args.at, args.duration)
result = matrix.get_matrix()
print("protocol,server,server_ip,port,server_proc,server_procname,"
"client,client_ip,client_proc,client_procname")
for e in result:
print(e)
if args.list_no_peers:
print("peer not found for connection:")
for cnx in matrix.unknown_cnx:
socket = cnx["socket"]
print(socket["Protocol"], cnx["node"].host, socket["RemotePort"],
socket)
def test_topology_rules(self):
restclient = RESTClient("localhost:8082",
scheme=self.schemeHTTP,
username=self.username,
password=self.password,
insecure=True)
noderule1 = restclient.noderule_create(
"create", metadata={"Name": "node1", "Type": "fabric"})
noderule2 = restclient.noderule_create(
"create", metadata={"Name": "node2", "Type": "fabric"})
time.sleep(1)
edgerule = restclient.edgerule_create(
"G.V().Has('Name', 'node1')", "G.V().Has('Name', 'node2')",
{"RelationType": "layer2", "EdgeName": "my_edge"})
time.sleep(1)
node1 = restclient.lookup_nodes("G.V().Has('Name', 'node1')")
self.assertEqual(len(node1), 1, "should find only one node as node1")
node2 = restclient.lookup_nodes("G.V().Has('Name', 'node2')")
self.assertEqual(len(node2), 1, "should find only one node as node2")
edge = restclient.lookup_edges(
"G.E().Has('RelationType', 'layer2', 'EdgeName', 'my_edge')")
self.assertEqual(len(edge), 1, "should find only one edge")
restclient.edgerule_delete(edgerule.uuid)
restclient.noderule_delete(noderule1.uuid)
restclient.noderule_delete(noderule2.uuid)
from skydive.rest.client import RESTClient
import yaml
conf_vars = yaml.load(open('tests_conf.yaml'))
SKYDIVE_IP = conf_vars.get('skydive_ip', '9.148.244.26')
SKYDIVE_PORT = conf_vars.get('skydive_port', '30777')
restclient = RESTClient(SKYDIVE_IP + ":" + SKYDIVE_PORT)
captures = restclient.capture_list()
print("capture before")
for capture in captures:
print("capture", capture)
restclient.capture_create(
"G.V().Has('Manager', NE('k8s'),'Docker.Labels.app', Regex('.*wordpress.*'),'Docker.Labels.tier', Regex('frontend')).Both().Out('Name','eth0')"
)
print("captures after")
captures = restclient.capture_list()
for capture in captures:
print("capture", capture)