def display_costs(project: Project, routers: Routers):
for router in routers.values():
conf = resolve_router_config(router)
for intf in conf['interfaces']:
try:
cost = intf['ospf6_cost']
for ri in router.interfaces:
ro_int: Interface = ri
if ro_int.name == intf['name']:
peer = ro_int.peer
x = int((router.x * 1.5 + peer.x * 0.5) / 2)
y = int((router.y * 1.5 + peer.y * 0.5) / 2)
project.create_drawing(
svg=
f'<svg width="80" height="35">{MAGIC_SVG}<rect width="80" height="35" fill="#000000" fill-opacity="1.0"/></svg>',
x=x + 1,
y=y + 5,
locked=True)
project.create_drawing(
svg=
f'<svg width=\"39\" height=\"30\"><!-- fait par le script --><text font-family=\"TypeWriter\" font-size=\"10.0\" font-weight=\"bold\" fill=\"#ffffff\" stroke=\"#afafe1\" stroke-width=\"100\" fill-opacity=\"1.0\">ospf6_cost\n {cost}</text></svg>',
x=x,
y=y,
locked=True)
except KeyError:
continue
except Exception as e:
raise e
def delete_drawings(project: Project):
if project.drawings is not None:
for draw in project.drawings:
s = draw['svg']
if s.split('>',
1)[1].startswith(MAGIC_SVG): # or not draw['locked']:
try:
project.update_drawing(drawing_id=draw['drawing_id'],
locked=False)
project.delete_drawing(drawing_id=draw['drawing_id'])
except Exception as e:
print(e.args)
pass
def display_router_ids(project: Project, routers: Routers):
# affiche les router-ids et les ASN
for node in routers.values():
x = node.x
y = node.y + 10
try:
project.create_drawing(
svg=
f'<svg width="60" height="15">{MAGIC_SVG}<rect width="60" height="15" fill="#ffffff" fill-opacity="1.0"/></svg>',
x=x,
y=y,
locked=True)
project.create_drawing(
svg=
f'<svg width="100" height="15">{MAGIC_SVG}<text>{node.router_id}\n {node.asn}</text></svg>',
x=x,
y=y - 4,
locked=True)
except AttributeError: # des fois GNS3 est pas content
pass
def createProject(server, project):
projectObj = Project(name=project, connector=server)
#print(projectObj.status)
# if projectObj.status == "opened":
# print("Closing the current project...", end="")
# projectObj.close()
# print("OK")
getProject = next((project
for project in server.projects_summary(is_print=False)
if project[0] == projectObj.name), "Project not found")
if getProject[0] == projectObj.name:
print("Project name existed, re-creating the project...", end="")
deleteProject(getProject[1])
#else:
# print("Creating the project...", end="")
projectObj.create()
print("Project " + projectObj.name + " created. ID: " +
projectObj.project_id + "...",
end="")
return projectObj
def display_tracked_subnets(project: Project, liens: List[Lien]):
# affiche les subnets entre routeurs
for lien in liens:
text = f"{lien.network4_display}"
x = (lien.side_a.x + lien.side_b.x) // 2 - 25
y = (lien.side_a.y + lien.side_b.y) // 2
try:
project.create_drawing(
svg=
f'<svg width="125" height="40">{MAGIC_SVG}<rect width="125" height="40" fill="#ffffff" fill-opacity="1.0" stroke-width="2" stroke="#000000"/></svg>',
x=x,
y=y,
z=1,
locked=True)
project.create_drawing(
svg=
f'<svg width="39" height="30">{MAGIC_SVG}<text font-family="TypeWriter" font-size="10.0" font-weight="bold" fill="#346c59" stroke="#afafe1" stroke-width="100" fill-opacity="1.0">{text}\n</text>'
+ '</svg>',
x=x,
y=y,
z=100,
locked=True)
except AttributeError:
pass # truc à la con de l'API gns3 qui arrive temps en temps
def main():
module = AnsibleModule(
argument_spec=dict(
url=dict(type="str", required=True),
port=dict(type="int", default=3080),
user=dict(type="str", default=None),
password=dict(type="str", default=None, no_log=True),
project_name=dict(type="str", default=None),
project_id=dict(type="str", default=None),
),
required_one_of=[["project_name", "project_id"]],
)
if not HAS_GNS3FY:
module.fail_json(msg=missing_required_lib("gns3fy"),
exception=GNS3FY_IMP_ERR)
result = dict(changed=False, nodes_inventory=None, total_nodes=None)
server_url = module.params["url"]
server_port = module.params["port"]
server_user = module.params["user"]
server_password = module.params["password"]
project_name = module.params["project_name"]
project_id = module.params["project_id"]
# Create server session
server = Gns3Connector(url=f"{server_url}:{server_port}",
user=server_user,
cred=server_password)
# Define the project
if project_name is not None:
project = Project(name=project_name, connector=server)
elif project_id is not None:
project = Project(project_id=project_id, connector=server)
# Retrieve project info
project.get()
nodes_inventory = project.nodes_inventory()
result.update(nodes_inventory=nodes_inventory,
total_nodes=len(nodes_inventory.keys()))
module.exit_json(**result)
def main():
module = AnsibleModule(argument_spec=dict(
remote_addr=dict(type="str", required=True),
port=dict(type="int", required=True),
login_prompt=dict(type="list", default=None),
user=dict(type="str", default=None),
password=dict(type="str", default=None, no_log=True),
enable_password=dict(type="str", default="", no_log=True),
send_newline=dict(type="bool", default=False),
prompts=dict(type="list", default=["[#$]"]),
root_set_user_prompts=dict(type="list", default=None),
root_set_password_prompts=dict(type="list", default=None, no_log=True),
config_dialog=dict(type="bool", default=False),
timeout=dict(type="dict", default=TIMEOUTS),
command=dict(type="list", required=True),
pause=dict(type="int", default=1),
pre_login_action=dict(
type="str",
choices=["xr9k_reboot_node", "nxos9k_disable_poap"],
default=None,
),
post_login_action=dict(
type="str",
choices=["eos_disable_ztp", "junos_enter_cli", "xr_wait_system"],
default=None,
),
gns3fy_data=dict(type="dict", default=None),
))
if not HAS_PEXPECT:
module.fail_json(msg=missing_required_lib("pexpect"),
exception=PEXPECT_IMP_ERR)
result = dict(changed=False)
remote_addr = module.params["remote_addr"]
port = module.params["port"]
login_prompt = module.params["login_prompt"]
user = module.params["user"]
password = module.params["password"]
enable_password = module.params["enable_password"]
send_newline = module.params["send_newline"]
prompts = module.params["prompts"]
root_set_user_prompts = module.params["root_set_user_prompts"]
root_set_password_prompts = module.params["root_set_password_prompts"]
config_dialog = module.params["config_dialog"]
timeout = set_missing_timeouts(module.params["timeout"])
command = module.params["command"]
pause = module.params["pause"]
pre_login_action = module.params["pre_login_action"]
post_login_action = module.params["post_login_action"]
gns3fy_data = module.params["gns3fy_data"]
conn = pexpect.spawn(
f"telnet {remote_addr} {port}",
timeout=timeout["general"],
maxread=4092,
encoding="utf-8",
searchwindowsize=2000,
ignore_sighup=True,
)
# Sends newline at the beginning of the connections
if send_newline:
conn.sendline("\r")
# Pre-login actions: Depends on the platform and image, for example it can be to
# reboot the node or disable POAP
if pre_login_action:
# NXOS 9K Disable POAP
if pre_login_action == "nxos9k_disable_poap":
try:
# TODO: around 60
conn.expect(
["Starting Auto Provisioning", pexpect.TIMEOUT],
timeout=timeout["pre_login"],
)
conn.sendline("\r")
conn.expect(["Abort Power On Auto Provisioning"])
conn.sendline("yes")
conn.expect(
["Do you want to enforce secure password standard"])
conn.sendline("no")
except pexpect.EOF:
raise AnsibleError(
f"on nxos9k_disable_poap EOF: {conn.before}")
except pexpect.TIMEOUT:
raise AnsibleError(
f"on nxos9k_disable_poap TIMEOUT: {conn.before}")
# XR 9K Reboot node first
elif pre_login_action == "xr9k_reboot_node":
if not HAS_GNS3FY:
module.fail_json(msg=missing_required_lib("gns3fy"),
exception=GNS3FY_IMP_ERR)
server = Gns3Connector(
url=f"{gns3fy_data['url']}:{gns3fy_data.get('port', 3080)}")
lab = Project(name=gns3fy_data.get("project_name"),
connector=server)
lab.get()
node = lab.get_node(gns3fy_data.get("node_name"))
try:
# TODO: around 60
conn.expect(["reboot: Restarting"],
timeout=timeout["pre_login"])
node.stop()
node.start()
except pexpect.EOF:
raise AnsibleError(f"on xr9k_reboot_node EOF: {conn.before}")
except pexpect.TIMEOUT:
node.stop()
node.start()
time.sleep(10)
# TODO: around 30
i = conn.expect(
["Cisco IOS XR console", pexpect.EOF, pexpect.TIMEOUT],
timeout=timeout["pre_login"],
)
if i == 0:
conn.sendline("\r")
elif i == 1:
try:
# TODO: around 30
conn.expect(root_set_user_prompts,
timeout=timeout["pre_login"])
except pexpect.EOF:
conn.close(force=True)
# TODO: Set as general timeout (which should be high)
conn = pexpect.spawn(
f"telnet {remote_addr} {port}",
timeout=timeout["general"],
maxread=4092,
encoding="utf-8",
searchwindowsize=2000,
ignore_sighup=True,
)
# Pause to send command after device initialization
time.sleep(360)
conn.sendline("\r")
conn.sendline("\r")
except pexpect.TIMEOUT:
conn.sendline("\r")
# Root user section
if root_set_user_prompts:
try:
conn.expect(root_set_user_prompts)
conn.sendline(user)
except pexpect.EOF:
raise AnsibleError(f"on root_set_user_prompts EOF: {conn.before}")
except pexpect.TIMEOUT:
raise AnsibleError(
f"on root_set_user_prompts TIMEOUT: {conn.before}")
if root_set_password_prompts:
while True:
try:
conn.expect(root_set_password_prompts, timeout=5)
conn.sendline(password)
except pexpect.EOF:
raise AnsibleError(
f"on root_set_password_prompts EOF: {conn.before}")
except pexpect.TIMEOUT:
time.sleep(pause)
conn.sendline("\r")
break
# Configuration Dialog section
if config_dialog:
# TODO: Was set as general timeout
i = conn.expect(
["[bB]asic|initial [cC]onfiguration [dD]ialog", pexpect.TIMEOUT],
timeout=timeout["config_dialog"],
)
if i == 0:
conn.sendline("no")
time.sleep(pause)
# TODO: Was set as general timeout
i = conn.expect(
["terminate autoinstall?", pexpect.TIMEOUT],
timeout=timeout["config_dialog"],
)
if i == 0:
conn.sendline("yes")
time.sleep(pause)
conn.sendline("\r")
# Main login prompt section
if login_prompt:
# TODO: Was set as general timeout
login_prompt_resolve(
conn,
login_prompt,
user,
password,
enable_password,
prompts,
timeout=timeout["login_prompt"],
)
# Post-login actions: Depends on the platform and image, for example it can be to
# disable ZTP, enter CLI prompt or just wait for system initialization
if post_login_action:
if post_login_action == "eos_disable_ztp":
conn.sendline("\r")
i = conn.expect([">", *prompts])
if i == 0:
enable_prompt_resolve(conn, enable_password, prompts)
conn.sendline("zerotouch disable")
time.sleep(pause)
conn.sendline("wr mem")
time.sleep(pause)
conn.sendline("reload force")
# TODO: Was set to 240
login_prompt_resolve(
conn,
login_prompt,
user,
password,
enable_password,
prompts,
timeout=timeout["general"],
use_prompts=False,
)
elif post_login_action == "junos_enter_cli":
conn.sendline("\r")
i = conn.expect(["%", *prompts])
if i == 0:
conn.sendline("cli")
time.sleep(pause)
elif post_login_action == "xr_wait_system":
conn.sendline("\r")
time.sleep(pause)
# TODO: Was set to 60
i = conn.expect(
[
"SYSTEM CONFIGURATION COMPLETED", pexpect.EOF,
pexpect.TIMEOUT
],
timeout=timeout["post_login"],
)
if i == 0:
conn.sendline("\r")
# Commands push
for comm in command:
for prompt in prompts:
try:
conn.sendline("\r")
time.sleep(pause)
conn.expect(prompt)
conn.sendline(comm)
time.sleep(pause)
result["changed"] = True
except pexpect.EOF:
raise AnsibleError(f"on commands enable EOF: {conn.before}")
except pexpect.TIMEOUT:
raise AnsibleError(f"on commands TIMEOUT: {conn.before}")
conn.close()
result.update(stdout=conn.before)
module.exit_json(**result)
def main():
module = AnsibleModule(
argument_spec=dict(
url=dict(type="str", required=True),
port=dict(type="int", default=3080),
user=dict(type="str", default=None),
password=dict(type="str", default=None, no_log=True),
project_name=dict(type="str", default=None),
project_id=dict(type="str", default=None),
data=dict(type="str", default=None),
dest=dict(type="str", required=True),
state=dict(type="str", choices=["present", "absent"], default="present"),
),
required_one_of=[["project_name", "project_id"]],
)
if not HAS_GNS3FY:
module.fail_json(msg=missing_required_lib("gns3fy"), exception=GNS3FY_IMP_ERR)
result = dict(changed=False)
server_url = module.params["url"]
server_port = module.params["port"]
server_user = module.params["user"]
server_password = module.params["password"]
project_name = module.params["project_name"]
project_id = module.params["project_id"]
data = module.params["data"]
dest = module.params["dest"]
state = module.params["state"]
if state == "present" and data is None:
module.fail_json(msg="Parameter needs to be passed: data", **result)
# Create server session
server = Gns3Connector(
url=f"{server_url}:{server_port}", user=server_user, cred=server_password
)
# Define the project
if project_name is not None:
project = Project(name=project_name, connector=server)
elif project_id is not None:
project = Project(project_id=project_id, connector=server)
if project is None:
module.fail_json(msg="Could not retrieve project. Check name", **result)
# Retrieve project info
project.get()
# Try to get file data
try:
file_data = project.get_file(path=dest)
except Exception as err:
if "Not Found" in str(err):
file_data = None
else:
module.fail_json(msg=str(err), exception=traceback.format_exc())
if state == "absent":
if file_data is None or file_data == "":
result.update(changed=False)
else:
# Delete project file data
# As of now (GNS3 v2.2.rc5) the DELETE method is not allowed
project_write_file(module, project, dest, "")
result.update(changed=True)
elif state == "present":
if file_data == data:
result.update(changed=False)
else:
project_write_file(module, project, dest, data)
result.update(changed=True)
module.exit_json(**result)
def main():
module = AnsibleModule(
argument_spec=dict(
url=dict(type="str", required=True),
port=dict(type="int", default=3080),
user=dict(type="str", default=None),
password=dict(type="str", default=None, no_log=True),
state=dict(
type="str",
required=True,
choices=["opened", "closed", "present", "absent"],
),
project_name=dict(type="str", default=None),
project_id=dict(type="str", default=None),
nodes_state=dict(type="str", choices=["started", "stopped"]),
nodes_strategy=dict(type="str",
choices=["all", "one_by_one"],
default="all"),
nodes_delay=dict(type="int", default=10),
poll_wait_time=dict(type="int", default=5),
nodes_spec=dict(type="list"),
links_spec=dict(type="list"),
),
supports_check_mode=True,
required_one_of=[["project_name", "project_id"]],
required_if=[["nodes_strategy", "one_by_one", ["nodes_delay"]]],
)
result = dict(changed=False)
if not HAS_GNS3FY:
module.fail_json(msg=missing_required_lib("gns3fy"),
exception=GNS3FY_IMP_ERR)
if module.check_mode:
module.exit_json(**result)
server_url = module.params["url"]
server_port = module.params["port"]
server_user = module.params["user"]
server_password = module.params["password"]
state = module.params["state"]
project_name = module.params["project_name"]
project_id = module.params["project_id"]
nodes_state = module.params["nodes_state"]
nodes_strategy = module.params["nodes_strategy"]
nodes_delay = module.params["nodes_delay"]
poll_wait_time = module.params["poll_wait_time"]
nodes_spec = module.params["nodes_spec"]
links_spec = module.params["links_spec"]
try:
# Create server session
server = Gns3Connector(url=f"{server_url}:{server_port}",
user=server_user,
cred=server_password)
# Define the project
if project_name is not None:
project = Project(name=project_name, connector=server)
elif project_id is not None:
project = Project(project_id=project_id, connector=server)
except Exception as err:
module.fail_json(msg=str(err), **result)
# Retrieve project information
try:
project.get()
pr_exists = True
except Exception as err:
pr_exists = False
reason = str(err)
if state == "opened":
if pr_exists:
if project.status != "opened":
# Open project
project.open()
# Now verify nodes
if nodes_state is not None:
# Change flag based on the nodes state
result["changed"] = nodes_state_verification(
expected_nodes_state=nodes_state,
nodes_strategy=nodes_strategy,
nodes_delay=nodes_delay,
poll_wait_time=poll_wait_time,
project=project,
)
else:
# Means that nodes are not taken into account for idempotency
result["changed"] = True
# Even if the project is open if nodes_state has been set, check it
else:
if nodes_state is not None:
result["changed"] = nodes_state_verification(
expected_nodes_state=nodes_state,
nodes_strategy=nodes_strategy,
nodes_delay=nodes_delay,
poll_wait_time=poll_wait_time,
project=project,
)
else:
module.fail_json(msg=reason, **result)
elif state == "closed":
if pr_exists:
if project.status != "closed":
# Close project
project.close()
result["changed"] = True
else:
module.fail_json(msg=reason, **result)
elif state == "present":
if pr_exists:
if nodes_spec is not None:
# Need to verify if nodes exist
_nodes_already_created = [node.name for node in project.nodes]
for node_spec in nodes_spec:
if node_spec["name"] not in _nodes_already_created:
# Open the project in case it was closed
project.open()
create_node(node_spec, project, module)
result["changed"] = True
if links_spec is not None:
for link_spec in links_spec:
project.open()
# Trigger another get to refresh nodes attributes
project.get()
# Link verification is already built in the library
created = create_link(link_spec, project, module)
if created:
result["changed"] = True
else:
# Create project
project.create()
# Nodes section
if nodes_spec is not None:
for node_spec in nodes_spec:
create_node(node_spec, project, module)
# Links section
if links_spec is not None:
for link_spec in links_spec:
create_link(link_spec, project, module)
result["changed"] = True
elif state == "absent":
if pr_exists:
# Stop nodes and close project to perform delete gracefully
if project.status != "opened":
# Project needs to be opened in order to be deleted...
project.open()
project.stop_nodes(poll_wait_time=0)
project.delete()
result["changed"] = True
else:
module.exit_json(**result)
# Return the project data
result["project"] = return_project_data(project)
module.exit_json(**result)
from gns3fy import Gns3Connector, Project
server = Gns3Connector("http://localhost:3080")
project = Project(name="topology_container", connector=server)
project.get()
project.open()
print(project)
def main():
module = AnsibleModule(
argument_spec=dict(
url=dict(type="str", required=True),
user=dict(type="str", default=None),
password=dict(type="str", default=None, no_log=True),
port=dict(type="int", default=3080),
state=dict(type="str",
required=True,
choices=["present", "absent", "restore"]),
project_name=dict(type="str", default=None),
project_id=dict(type="str", default=None),
snapshot_name=dict(type="str", default=None),
snapshot_id=dict(type="str", default=None),
),
required_one_of=[
["project_name", "project_id"],
["snapshot_name", "snapshot_id"],
],
)
result = dict(changed=False)
if not HAS_GNS3FY:
module.fail_json(msg=missing_required_lib("gns3fy"),
exception=GNS3FY_IMP_ERR)
server_url = module.params["url"]
server_port = module.params["port"]
server_user = module.params["user"]
server_password = module.params["password"]
project_name = module.params["project_name"]
project_id = module.params["project_id"]
snapshot_name = module.params["snapshot_name"]
snapshot_id = module.params["snapshot_id"]
state = module.params["state"]
try:
# Create server session
server = Gns3Connector(url=f"{server_url}:{server_port}",
user=server_user,
cred=server_password)
# Define the project
if project_name is not None:
project = Project(name=project_name, connector=server)
elif project_id is not None:
project = Project(project_id=project_id, connector=server)
# Collect project and snapshots data
project.get()
snapshot = project.get_snapshot(name=snapshot_name,
snapshot_id=snapshot_id)
if state == "present":
if snapshot is None:
# Create the snapshot
if not snapshot_name:
module.fail_json(
msg="Need to specify snapshot name for creation",
**result)
project.create_snapshot(name=snapshot_name)
result["changed"] = True
result["snapshot"] = project.get_snapshot(
name=snapshot_name, snapshot_id=snapshot_id)
else:
result["snapshot"] = snapshot
elif state == "absent":
if snapshot:
# Delete snapshot
project.delete_snapshot(name=snapshot_name,
snapshot_id=snapshot_id)
result["changed"] = True
elif state == "restore":
if not snapshot:
module.fail_json(msg="Snapshot not found", **result)
# Restore snapshot
project.restore_snapshot(name=snapshot_name,
snapshot_id=snapshot_id)
result["changed"] = True
result["snapshot"] = snapshot
module.exit_json(**result)
except Exception as err:
module.fail_json(msg=str(err), **result)
from gns3fy import Gns3Connector, Project
from tabulate import tabulate
server = Gns3Connector("http://localhost:3080")
lab = Project(name="topology_container", connector=server)
lab.get()
print(lab)
print('\n--------------------------------\n')
nodes = lab.nodes_summary(is_print=False)
print(tabulate(nodes))
print('\n--------------------------------\n')
links = lab.links_summary(is_print=False)
print(tabulate(links))
def main():
# Parse the arguments
args = parse_args()
topology_data = load_yaml(args.topology)
# Collect lab name
print(heading("Collecting topology data"))
lab_name: str = topology_data["title"]["text"]
print(f"The lab name would be: {lab_name}")
# Collect nodes specs
nodes_spec = get_nodes_spec(topology_data["icons"])
# Collect connections specs
links_spec = get_links_spec(topology_data["connections"])
# Create Gns3Connector
print(heading(f"Configuring lab on GNS3 server"))
server = Gns3Connector(f"{args.protocol}://{args.server}:{args.port}")
# Verify lab is not already created
lab_project = server.get_project(name=lab_name)
if lab_project:
delete_lab = input(
f"\nLab already created, do you want to delete it? (y/n): ")
if delete_lab == "y":
server.delete_project(lab_project["project_id"])
else:
sys.exit("Exiting...")
# Create the lab
lab = Project(name=lab_name, connector=server)
lab.create()
print(f"Project created: {lab.name}\n")
# Create the nodes
for device in nodes_spec:
node = Node(
project_id=lab.project_id,
connector=server,
name=device["name"],
template=device["template"],
x=parsed_x(device["x"] - 10),
y=parsed_y(device["y"] - 5),
)
node.create()
time.sleep(3)
print(f"Device created: {node.name}")
# Create the links
for link in links_spec:
lab.create_link(*link)
# Summary
print(heading("Nodes Summary"))
nodes_summary: str = lab.nodes_summary(is_print=False)
print(
tabulate(nodes_summary,
headers=["Device", "Status", "Console Port", "ID"]))
print(heading("Links Summary"))
links_summary: str = lab.links_summary(is_print=False)
print(
tabulate(links_summary,
headers=["Device A", "Port A", "Device B", "Port B"]))
return
def OpenProject(project_id, project_name, gns3_server): project = Project(project_id=project_id, name=project_name, connector=gns3_server) project.get() project.open()
def main():
module = AnsibleModule(
argument_spec=dict(
url=dict(type="str", required=True),
port=dict(type="int", default=3080),
user=dict(type="str", default=None),
password=dict(type="str", default=None, no_log=True),
state=dict(
type="str",
required=True,
choices=["started", "stopped", "suspended", "reload"],
),
project_name=dict(type="str", default=None),
project_id=dict(type="str", default=None),
node_name=dict(type="str", default=None),
node_id=dict(type="str", default=None),
retry=dict(type="bool", default=False),
poll_wait_time=dict(type="int", default=5),
force_project_open=dict(type="bool", default=False),
),
required_one_of=[["project_name", "project_id"],
["node_name", "node_id"]],
)
result = dict(changed=False)
if not HAS_GNS3FY:
module.fail_json(msg=missing_required_lib("gns3fy"),
exception=GNS3FY_IMP_ERR)
server_url = module.params["url"]
server_port = module.params["port"]
server_user = module.params["user"]
server_password = module.params["password"]
state = module.params["state"]
project_name = module.params["project_name"]
project_id = module.params["project_id"]
node_name = module.params["node_name"]
node_id = module.params["node_id"]
retry = module.params["retry"]
poll_wait_time = module.params["poll_wait_time"]
force_project_open = module.params["force_project_open"]
try:
# Create server session
server = Gns3Connector(url=f"{server_url}:{server_port}",
user=server_user,
cred=server_password)
# Define the project
if project_name is not None:
project = Project(name=project_name, connector=server)
elif project_id is not None:
project = Project(project_id=project_id, connector=server)
if project is None:
module.fail_json(msg="Could not retrieve project. Check name",
**result)
project.get()
if project.status != "opened" and force_project_open:
project.open()
# Retrieve node
if node_name is not None:
node = project.get_node(name=node_name)
elif node_id is not None:
node = project.get_node(node_id=node_id)
if node is None:
module.fail_json(msg="Could not retrieve node. Check name",
**result)
except Exception as err:
module.fail_json(msg=str(err), **result)
# Apply state change
result["changed"] = state_verification(expected_state=state,
node=node,
retry=retry,
poll_wait_time=poll_wait_time)
# Return the node data
result["node"] = return_node_data(node)
module.exit_json(**result)