def __init__(self, app: "Application", proxy: bool) -> None:
"""
Create a CoreGrpc instance
"""
self.app: "Application" = app
self.master: tk.Tk = app.master
self._client: client.CoreGrpcClient = client.CoreGrpcClient(
proxy=proxy)
self.session: Optional[Session] = None
self.user = getpass.getuser()
# global service settings
self.services: Dict[str, Set[str]] = {}
self.config_services_groups: Dict[str, Set[str]] = {}
self.config_services: Dict[str, ConfigService] = {}
# loaded configuration data
self.servers: Dict[str, CoreServer] = {}
self.custom_nodes: Dict[str, NodeDraw] = {}
self.custom_observers: Dict[str, Observer] = {}
self.read_config()
# helpers
self.iface_to_edge: Dict[Tuple[int, ...], CanvasEdge] = {}
self.ifaces_manager: InterfaceManager = InterfaceManager(self.app)
self.observer: Optional[str] = None
# session data
self.mobility_players: Dict[int, MobilityPlayer] = {}
self.canvas_nodes: Dict[int, CanvasNode] = {}
self.links: Dict[str, CanvasEdge] = {}
self.handling_throughputs: Optional[grpc.Future] = None
self.handling_cpu_usage: Optional[grpc.Future] = None
self.handling_events: Optional[grpc.Future] = None
def main(args):
# helper to create interfaces
interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/16")
# create grpc client and connect
core = client.CoreGrpcClient()
core.connect()
# create session
session = core.create_session()
# add distributed server
server = Server(name="core2", host=args.server)
session.servers.append(server)
# handle events session may broadcast
core.events(session.id, log_event)
# create switch node
position = Position(x=150, y=100)
switch = session.add_node(1, _type=NodeType.SWITCH, position=position)
position = Position(x=100, y=50)
node1 = session.add_node(2, position=position)
position = Position(x=200, y=50)
node2 = session.add_node(3, position=position, server=server.name)
# create links
iface1 = interface_helper.create_iface(node1.id, 0)
session.add_link(node1=node1, node2=switch, iface1=iface1)
iface1 = interface_helper.create_iface(node2.id, 0)
session.add_link(node1=node2, node2=switch, iface1=iface1)
# start session
core.start_session(session)
def main(args):
core = client.CoreGrpcClient()
with core.context_connect():
# create session
response = core.create_session()
session_id = response.session_id
logging.info("created session: %s", response)
# add distributed server
server_name = "core2"
response = core.add_session_server(session_id, server_name,
args.server)
logging.info("added session server: %s", response)
# handle events session may broadcast
core.events(session_id, log_event)
# change session state
response = core.set_session_state(session_id,
SessionState.CONFIGURATION)
logging.info("set session state: %s", response)
# create switch node
switch = Node(type=NodeType.SWITCH)
response = core.add_node(session_id, switch)
logging.info("created switch: %s", response)
switch_id = response.node_id
# helper to create interfaces
interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/16")
# create node one
position = Position(x=100, y=50)
node = Node(position=position)
response = core.add_node(session_id, node)
logging.info("created node one: %s", response)
node1_id = response.node_id
# create link
interface1 = interface_helper.create_iface(node1_id, 0)
response = core.add_link(session_id, node1_id, switch_id, interface1)
logging.info("created link from node one to switch: %s", response)
# create node two
position = Position(x=200, y=50)
node = Node(position=position, server=server_name)
response = core.add_node(session_id, node)
logging.info("created node two: %s", response)
node2_id = response.node_id
# create link
interface1 = interface_helper.create_iface(node2_id, 0)
response = core.add_link(session_id, node2_id, switch_id, interface1)
logging.info("created link from node two to switch: %s", response)
# change session state
response = core.set_session_state(session_id,
SessionState.INSTANTIATION)
logging.info("set session state: %s", response)
def main():
# helper to create interface addresses
interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/24")
# create grpc client and start connection context, which auto closes connection
core = client.CoreGrpcClient()
with core.context_connect():
# create session
response = core.create_session()
logging.info("created session: %s", response)
# handle events session may broadcast
session_id = response.session_id
core.events(session_id, log_event)
# change session state to configuration so that nodes get started when added
response = core.set_session_state(session_id,
SessionState.CONFIGURATION)
logging.info("set session state: %s", response)
# create emane node
position = Position(x=200, y=200)
emane = Node(type=NodeType.EMANE, position=position)
response = core.add_node(session_id, emane)
logging.info("created emane: %s", response)
emane_id = response.node_id
# an emane model must be configured for use, by the emane node
core.set_emane_model_config(session_id, emane_id,
EmaneIeee80211abgModel.name)
# create node one
position = Position(x=100, y=100)
node1 = Node(type=NodeType.DEFAULT, position=position)
response = core.add_node(session_id, node1)
logging.info("created node: %s", response)
node1_id = response.node_id
# create node two
position = Position(x=300, y=100)
node2 = Node(type=NodeType.DEFAULT, position=position)
response = core.add_node(session_id, node2)
logging.info("created node: %s", response)
node2_id = response.node_id
# links nodes to switch
interface1 = interface_helper.create_iface(node1_id, 0)
response = core.add_link(session_id, node1_id, emane_id, interface1)
logging.info("created link: %s", response)
interface1 = interface_helper.create_iface(node2_id, 0)
response = core.add_link(session_id, node2_id, emane_id, interface1)
logging.info("created link: %s", response)
# change session state
response = core.set_session_state(session_id,
SessionState.INSTANTIATION)
logging.info("set session state: %s", response)
def __init__(self, app: "Application", proxy: bool):
"""
Create a CoreGrpc instance
"""
self._client = client.CoreGrpcClient(proxy=proxy)
self.session_id = None
self.node_ids = []
self.app = app
self.master = app.master
self.services = {}
self.config_services_groups = {}
self.config_services = {}
self.default_services = {}
self.emane_models = []
self.observer = None
# loaded configuration data
self.servers = {}
self.custom_nodes = {}
self.custom_observers = {}
self.read_config()
# helpers
self.interface_to_edge = {}
self.interfaces_manager = InterfaceManager(self.app)
# session data
self.state = None
self.canvas_nodes = {}
self.location = None
self.links = {}
self.hooks = {}
self.wlan_configs = {}
self.mobility_configs = {}
self.emane_model_configs = {}
self.emane_config = None
self.service_configs = {}
self.config_service_configs = {}
self.file_configs = {}
self.mobility_players = {}
self.handling_throughputs = None
self.handling_events = None
self.xml_dir = None
self.xml_file = None
self.modified_service_nodes = set()
def main():
core = client.CoreGrpcClient()
with core.context_connect():
# create session
response = core.create_session()
logging.info("created session: %s", response)
# handle events session may broadcast
session_id = response.session_id
core.events(session_id, log_event)
# change session state
response = core.set_session_state(
session_id, core_pb2.SessionState.CONFIGURATION
)
logging.info("set session state: %s", response)
# create switch node
switch = core_pb2.Node(type=core_pb2.NodeType.SWITCH)
response = core.add_node(session_id, switch)
logging.info("created switch: %s", response)
switch_id = response.node_id
# helper to create interfaces
interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/16")
for i in range(2):
# create node
position = core_pb2.Position(x=50 + 50 * i, y=50)
node = core_pb2.Node(position=position)
response = core.add_node(session_id, node)
logging.info("created node: %s", response)
node_id = response.node_id
# create link
interface_one = interface_helper.create_interface(node_id, 0)
response = core.add_link(session_id, node_id, switch_id, interface_one)
logging.info("created link: %s", response)
# change session state
response = core.set_session_state(
session_id, core_pb2.SessionState.INSTANTIATION
)
logging.info("set session state: %s", response)
def main():
core = client.CoreGrpcClient()
with core.context_connect():
# create session
response = core.create_session()
session_id = response.session_id
logging.info("created session: %s", response)
# create nodes for session
nodes = []
position = core_pb2.Position(x=50, y=100)
switch = core_pb2.Node(id=1,
type=core_pb2.NodeType.SWITCH,
position=position)
nodes.append(switch)
for i in range(2, 50):
position = core_pb2.Position(x=50 + 50 * i, y=50)
node = core_pb2.Node(id=i, position=position, model="PC")
nodes.append(node)
# create links
interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/16")
links = []
for node in nodes:
interface_one = interface_helper.create_interface(node.id, 0)
link = core_pb2.Link(
type=core_pb2.LinkType.WIRED,
node_one_id=node.id,
node_two_id=switch.id,
interface_one=interface_one,
)
links.append(link)
# start session
response = core.start_session(session_id, nodes, links)
logging.info("started session: %s", response)
input("press enter to shutdown session")
response = core.stop_session(session_id)
logging.info("stop sessionL %s", response)
def __init__(self, app: "Application", proxy: bool) -> None:
"""
Create a CoreGrpc instance
"""
self.app: "Application" = app
self.master: tk.Tk = app.master
self._client: client.CoreGrpcClient = client.CoreGrpcClient(proxy=proxy)
self.session_id: Optional[int] = None
self.services: Dict[str, Set[str]] = {}
self.config_services_groups: Dict[str, Set[str]] = {}
self.config_services: Dict[str, ConfigService] = {}
self.default_services: Dict[NodeType, Set[str]] = {}
self.emane_models: List[str] = []
self.observer: Optional[str] = None
self.user = getpass.getuser()
# loaded configuration data
self.servers: Dict[str, CoreServer] = {}
self.custom_nodes: Dict[str, NodeDraw] = {}
self.custom_observers: Dict[str, Observer] = {}
self.read_config()
# helpers
self.iface_to_edge: Dict[Tuple[int, ...], Tuple[int, ...]] = {}
self.ifaces_manager: InterfaceManager = InterfaceManager(self.app)
# session data
self.state: Optional[SessionState] = None
self.canvas_nodes: Dict[int, CanvasNode] = {}
self.location: Optional[SessionLocation] = None
self.links: Dict[Tuple[int, int], CanvasEdge] = {}
self.hooks: Dict[str, Hook] = {}
self.emane_config: Dict[str, ConfigOption] = {}
self.mobility_players: Dict[int, MobilityPlayer] = {}
self.handling_throughputs: Optional[grpc.Future] = None
self.handling_cpu_usage: Optional[grpc.Future] = None
self.handling_events: Optional[grpc.Future] = None
self.xml_dir: Optional[str] = None
self.xml_file: Optional[str] = None
def main():
global uavs
global protocol
global nodepath
global mynodeseq
global nodecnt
global core
global session_id
#global ack_list
# Get command line inputs
parser = argparse.ArgumentParser()
parser.add_argument('-my',
'--my-id',
dest='uav_id',
metavar='my id',
type=int,
default='1',
help='My Node ID')
parser.add_argument('-c',
'--covered-zone',
dest='covered_zone',
metavar='covered zone',
type=int,
default='1200',
help='UAV covered zone limit on X axis')
parser.add_argument('-r',
'--track_range',
dest='track_range',
metavar='track range',
type=int,
default='600',
help='UAV tracking range')
parser.add_argument('-i',
'--update_interval',
dest='interval',
metavar='update interval',
type=int,
default='1',
help='Update Inteval')
parser.add_argument('-p',
'--protocol',
dest='protocol',
metavar='comms protocol',
type=str,
default='none',
help='Comms Protocol')
# Parse command line options
args = parser.parse_args()
protocol = args.protocol
# Create grpc client
core = client.CoreGrpcClient("172.16.0.254:50051")
core.connect()
response = core.get_sessions()
if not response.sessions:
raise ValueError("no current core sessions")
session_summary = response.sessions[0]
session_id = int(session_summary.id)
session = core.get_session(session_id).session
# Populate the uavs list with current UAV node information
mynodeseq = 0
node = CORENode(args.uav_id, -1)
uavs.append(node)
RedeployUAV(node)
RecordTarget(node)
nodecnt += 1
if mynodeseq == -1:
print("Error: my id needs to be in the list of UAV IDs")
sys.exit()
# Initialize values
corepath = "/tmp/pycore.*/"
nodepath = glob.glob(corepath)[0]
msecinterval = float(args.interval)
secinterval = msecinterval / 1000
#import pdb; pdb.set_trace()
#import pdb
#breakpoint()
#pdb.set_trace()
if protocol == "udp":
# Create UDP receiving thread
recvthrd = ReceiveUDPThread()
recvthrd.start()
# Start tracking targets
while 1:
time.sleep(secinterval)
if protocol == "udp":
thrdlock.acquire()
TrackTargets(args.covered_zone, args.track_range)
if protocol == "udp":
thrdlock.release()
# required imports
from core.api.grpc import client
from core.api.grpc.core_pb2 import Node, NodeType, Position, SessionState
# interface helper
iface_helper = client.InterfaceHelper(ip4_prefix="10.0.0.0/24",
ip6_prefix="2001::/64")
# create grpc client and connect
core = client.CoreGrpcClient()
core.connect()
# create session and get id
response = core.create_session()
session_id = response.session_id
# change session state to configuration so that nodes get started when added
core.set_session_state(session_id, SessionState.CONFIGURATION)
# create switch node
position = Position(x=200, y=200)
switch = Node(type=NodeType.SWITCH, position=position)
response = core.add_node(session_id, switch)
switch_id = response.node_id
# create node one
position = Position(x=100, y=100)
n1 = Node(type=NodeType.DEFAULT, position=position, model="PC")
response = core.add_node(session_id, n1)
n1_id = response.node_id
def main():
# helper to create interface addresses
interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/24")
# create grpc client and start connection context, which auto closes connection
core = client.CoreGrpcClient()
with core.context_connect():
# create session
response = core.create_session()
logging.info("created session: %s", response)
# handle events session may broadcast
session_id = response.session_id
core.events(session_id, log_event)
# change session state to configuration so that nodes get started when added
response = core.set_session_state(session_id,
SessionState.CONFIGURATION)
logging.info("set session state: %s", response)
# create wlan node
position = Position(x=200, y=200)
wlan = Node(type=NodeType.WIRELESS_LAN, position=position)
response = core.add_node(session_id, wlan)
logging.info("created wlan: %s", response)
wlan_id = response.node_id
# change/configure wlan if desired
# NOTE: error = loss, and named this way for legacy purposes for now
config = {
"bandwidth": "54000000",
"range": "500",
"jitter": "0",
"delay": "5000",
"error": "0",
}
response = core.set_wlan_config(session_id, wlan_id, config)
logging.info("set wlan config: %s", response)
# create node one
position = Position(x=100, y=100)
node1 = Node(type=NodeType.DEFAULT, position=position)
response = core.add_node(session_id, node1)
logging.info("created node: %s", response)
node1_id = response.node_id
# create node two
position = Position(x=300, y=100)
node2 = Node(type=NodeType.DEFAULT, position=position)
response = core.add_node(session_id, node2)
logging.info("created node: %s", response)
node2_id = response.node_id
# links nodes to switch
interface1 = interface_helper.create_iface(node1_id, 0)
response = core.add_link(session_id, node1_id, wlan_id, interface1)
logging.info("created link: %s", response)
interface1 = interface_helper.create_iface(node2_id, 0)
response = core.add_link(session_id, node2_id, wlan_id, interface1)
logging.info("created link: %s", response)
# change session state
response = core.set_session_state(session_id,
SessionState.INSTANTIATION)
logging.info("set session state: %s", response)
def main():
global targets
# Original waypoints
original_wypts = {
1: (100, 150),
2: (100, 300),
3: (100, 450),
4: (100, 600),
6: (400, 150),
7: (400, 300),
8: (400, 450),
9: (400, 600)
}
# Targets colors
colors = [
'blue', 'yellow', 'green', 'red', 'lime', 'orange', 'pink', 'purple',
'lavender', 'cyan'
]
targets = {
11: colors[0],
12: colors[1],
13: colors[2],
14: colors[3],
16: colors[4],
17: colors[5],
18: colors[6],
19: colors[7]
}
# Get command line inputs
if len(sys.argv) >= 7:
node_id = int(sys.argv[1])
xuav = int(sys.argv[2])
yuav = int(sys.argv[3])
rad = int(sys.argv[4])
speed = float(sys.argv[5])
msecduration = float(sys.argv[6])
duration = msecduration / 1000
else:
print("move_node.py nodenum xuav yuav radius speed duration(msec)\n")
sys.exit()
# Create grpc client
core = client.CoreGrpcClient("172.16.0.254:50051")
core.connect()
response = core.get_sessions()
if not response.sessions:
raise ValueError("no current core sessions")
session_summary = response.sessions[0]
session_id = int(session_summary.id)
session = core.get_session(session_id).session
# Set CORE UAV
node_wypt = original_wypts[node_id]
core_uav = CoreUav(core, session_id, node_id, xuav, yuav, node_wypt[0],
node_wypt[1])
# Initialize targets
SetColor(core, session_id, node_id, 'grey', "uav")
for target_id, color in targets.items():
SetColor(core, session_id, target_id, color, "target")
print("Start XML RPC thread")
# Initiate xmlrpc server
xml_rpc_server_thread = StartXmlRpcServerThread(core_uav)
xml_rpc_server_thread.start()
print("Start MOVE UAV thread")
# Move UAV node
while 1:
time.sleep(duration)
position = core_uav.getWypt()
xtrgt, ytrgt = position[0], position[1]
xuav, yuav = MoveVehicle(xuav, yuav, xtrgt, ytrgt, rad, speed,
duration)
#print("xuav: %d, yuav: %d" % (xuav, yuav))
# Find UAV color to set
target_id = core_uav.target
color = "grey"
if target_id in targets:
color = targets[target_id]
icon_file_path = iconpath + color + "_plane.png"
# Set position and keep current UAV color
pos = core_pb2.Position(x=xuav, y=yuav)
response = core.edit_node(session_id=session_id,
node_id=node_id,
position=pos,
icon=icon_file_path)
core_uav.setPosition(xuav, yuav)
