getadddropport(
    ena::MINDFul.EndNodeAllocations
) -> Union{Nothing, Int64}

getadddropport(
    ena::MINDFul.MutableEndNodeAllocations
) -> Union{Nothing, Int64}

getadddropport(
    oxcswitchentry::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Int64

getadddropport(
    tmlli::MINDFul.TransmissionModuleLLI
) -> Int64

getadddropportnumber(oxcview::MINDFul.OXCView) -> Int64

getborderedges(
    ibnf::MINDFul.IBNFramework
) -> Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}}

Return all border edges that contain at least one border node as endpoints

getborderglobaledges(ibnf::MINDFul.IBNFramework) -> Vector

Return all border edges that contain at least one border node as endpoints as global

getbordernodesasglobal(ibnf::MINDFul.IBNFramework) -> Vector

Return all border nodes of ibnf with globalnode representation

getbordernodesaslocal(ibnf::MINDFul.IBNFramework) -> Vector

Return all border nodes of ibnf with localnode representation

getconstraints(
    conintent::MINDFul.ConnectivityIntent
) -> Vector{T} where T<:MINDFul.AbstractIntentConstraint

getcost(s) -> Any

getcurrentstate(
    intentlogstate::Array{Tuple{Dates.DateTime, S}, 1} where S<:Enum{Int32}
) -> Enum{Int32}

getdestinationnode(
    conintent::MINDFul.ConnectivityIntent
) -> MINDFul.GlobalNode

getdestinationnode(
    lpr::MINDFul.LightpathRepresentation
) -> MINDFul.GlobalNode

getdestinationnode(
    otc::MINDFul.OpticalTerminateConstraint
) -> MINDFul.GlobalNode

getdistance(
    s
) -> Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}

getdistance(
    s::MINDFul.EdgeView
) -> Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}

getedgeview(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    ed::Graphs.SimpleGraphs.SimpleEdge
) -> MINDFul.EdgeView

getedgeviews(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView
) -> Vector

getfiberspectrumavailabilities(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    edge::Graphs.SimpleGraphs.SimpleEdge{Int64};
    checkfirst
) -> Union{Nothing, Vector{Bool}}

getfiberspectrumavailabilities(
    ibnf::MINDFul.IBNFramework,
    edge::Graphs.SimpleGraphs.SimpleEdge{Int64};
    checkfirst,
    verbose
) -> Any

Get the spectrum availability slots vector for edge

getglobalnode(s) -> MINDFul.GlobalNode

getglobalnode(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    localnode::Int64
) -> MINDFul.GlobalNode

Return the global representation given the local representation. Return nothing if not found

getglobalnode(
    splitglobalnode::MINDFul.SplitGlobalNode
) -> MINDFul.GlobalNode

getibnag(s) -> Any

Get the IBNAttributeGraph

getibnfhandler(
    s::MINDFul.IBNFramework,
    uuid::Base.UUID
) -> MINDFul.AbstractIBNFHandler

getibnfhandler(
    s::MINDFul.IBNFramework,
    globaledge::MINDFul.GlobalEdge
) -> Union{Nothing, MINDFul.AbstractIBNFHandler}

Return the handler of tyhe uuid of both global nodes from global edge. If these do not agree, return nothing

getibnfhandler(
    s::MINDFul.IBNFramework
) -> MINDFul.IBNFramework

Get the handler of the given IBNFramework.

getibnfhandlers(
    s::MINDFul.IBNFramework
) -> Vector{H} where H<:MINDFul.AbstractIBNFHandler

getibnfid(s) -> Base.UUID

Get the id of the IBNFramework

getibnfid(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView
) -> Base.UUID

getibnfid(ri::MINDFul.RemoteIntent) -> Base.UUID

getidag(
    s::MINDFul.IBNFramework
) -> AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}

Get the IntentDAG

getidagcounter(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Int64

getidagcounter(
    intentdaginfo::MINDFul.IntentDAGInfo
) -> Int64

getidagnodeid(idagnode::MINDFul.IntentDAGNode) -> Base.UUID

getidagnodeid(ri::MINDFul.RemoteIntent) -> Base.UUID

getidagnodestate(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    dagnodeid::Base.UUID
) -> MINDFul.IntentState.T

getidagnodestate(
    idagnode::MINDFul.IntentDAGNode
) -> MINDFul.IntentState.T

getinneighbors(np::MINDFul.NodeProperties) -> Vector{Int64}

getintent(
    idagnode::MINDFul.IntentDAGNode
) -> MINDFul.AbstractIntent

getintent(
    ri::MINDFul.RemoteIntent
) -> MINDFul.AbstractIntent

getintranodeviews(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView
) -> Vector{T} where T<:MINDFul.NodeView

getisinitiator(ri::MINDFul.RemoteIntent) -> Bool

getlatitude(np::MINDFul.NodeProperties) -> Float64

getlinkspectrumavailabilities(
    oxcview::MINDFul.OXCView
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Bool}}

getlocalnode(s) -> Int64

getlocalnode(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    globalnode::MINDFul.GlobalNode
) -> Any

Return the localnode representation given the global representation. Return nothing if not found

getlocalnode(ena::MINDFul.EndNodeAllocations) -> Int64

getlocalnode(
    ena::MINDFul.MutableEndNodeAllocations
) -> Int64

getlocalnode_input(
    ena::MINDFul.EndNodeAllocations
) -> Union{Nothing, Int64}

getlocalnode_input(
    ena::MINDFul.MutableEndNodeAllocations
) -> Union{Nothing, Int64}

getlocalnode_input(
    oxcswitchreservationentry::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Int64

getlocalnode_output(ena::MINDFul.MutableEndNodeAllocations)

getlocalnode_output(
    oxcswitchentry::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Int64

getlogstate(
    idagnode::MINDFul.IntentDAGNode
) -> Vector{Tuple{Dates.DateTime, MINDFul.IntentState.T}}

getlongitude(np::MINDFul.NodeProperties) -> Float64

getnodeproperties(
    s::MINDFul.NodeView
) -> MINDFul.NodeProperties

getnodeview(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    node::Int64
) -> MINDFul.NodeView

getnodeview(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    node::MINDFul.GlobalNode
) -> Any

getnodeview(
    ibnf::MINDFul.IBNFramework,
    node::Int64
) -> MINDFul.NodeView

getnodeviews(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView
) -> Vector{T} where T<:MINDFul.NodeView

getopticalinitiateconstraint(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID
) -> Union{Nothing, MINDFul.OpticalInitiateConstraint}

Get the OpticalInitiateConstraint for the current intent DAG. If the compilation is not optically terminated return nothing.

To me this has all the logic needed to be type stable but the compiler fails.

getopticalreach(
    tm::MINDFul.TransmissionMode
) -> Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}

getoutneighbors(np::MINDFul.NodeProperties) -> Vector{Int64}

getoxcadddropportindex(
    s::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Int64

getoxcview(
    s::MINDFul.NodeView
) -> Union{Nothing, MINDFul.OXCView}

getpathspectrumavailabilities(
    ibnf::MINDFul.IBNFramework,
    localnodespath::Vector{Int64};
    checkfirst
) -> Vector{Bool}

Get spectrum availabilities along a path of nodes as a BitVector

getportnumber(s) -> Int64

getportnumber(s::MINDFul.RouterView) -> Int64

getproperties(s::MINDFul.EdgeView) -> MINDFul.EdgeProperties

getproperties(s::MINDFul.NodeView) -> MINDFul.NodeProperties

getrate(
    conintent::MINDFul.ConnectivityIntent
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}

getrate(
    s::MINDFul.RouterPort
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}

getrate(
    tm::MINDFul.TransmissionMode
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}

getrate(
    tmc::MINDFul.TransmissionModuleCompatibility
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}

getreservations(
    nodeview::MINDFul.NodeView
) -> Union{Nothing, Dict{Base.UUID, MINDFul.TransmissionModuleLLI}}

getreservations(
    oxcview::MINDFul.OXCView
) -> Dict{Base.UUID, MINDFul.OXCAddDropBypassSpectrumLLI}

getreservations(
    routerview::MINDFul.RouterView
) -> Dict{Base.UUID, MINDFul.RouterPortLLI}

getreservedtransmissionmode(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{MINDFul.TransmissionModuleLLI};
    verbose
) -> Union{MINDFul.TransmissionMode, Symbol}

Get the reserved transmission mode

getrouterportindex(
    ena::MINDFul.EndNodeAllocations
) -> Union{Nothing, Int64}

getrouterportindex(
    ena::MINDFul.MutableEndNodeAllocations
) -> Union{Nothing, Int64}

getrouterportindex(s::MINDFul.RouterPortLLI) -> Int64

getrouterportindex(
    s::MINDFul.TransmissionModuleLLI
) -> Int64

getrouterview(
    s::MINDFul.NodeView
) -> Union{Nothing, MINDFul.RouterView}

getsdncontroller(s) -> Any

Get the sdn controller subtype of AbstractSDNController

getsourcenode(
    conintent::MINDFul.ConnectivityIntent
) -> MINDFul.GlobalNode

getspectrumavailability(s) -> Any

getspectrumslots(s) -> Any

getspectrumslotsneeded(
    tm::MINDFul.TransmissionMode
) -> Int64

getspectrumslotsneeded(
    tmc::MINDFul.TransmissionModuleCompatibility
) -> Int64

getspectrumslotsrange(
    lpintent::MINDFul.LightpathIntent
) -> UnitRange{Int64}

getspectrumslotsrange(
    oxcswitchentry::MINDFul.OXCAddDropBypassSpectrumLLI
) -> UnitRange{Int64}

gettransmissionmode(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    oxclli::MINDFul.TransmissionModuleLLI
) -> MINDFul.TransmissionMode

gettransmissionmode(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{MINDFul.TransmissionModuleLLI}
) -> MINDFul.TransmissionMode

Get the transmission mode

gettransmissionmode(
    ibnf::MINDFul.IBNFramework,
    intent::MINDFul.TransmissionModuleLLI
) -> MINDFul.TransmissionMode

Get the transmission mode

gettransmissionmode(
    s::MINDFul.TransmissionModuleView,
    transmissionmodeidx::Int64
) -> MINDFul.TransmissionMode

gettransmissionmodes(
    s::MINDFul.TransmissionModuleView
) -> Vector{MINDFul.TransmissionMode}

gettransmissionmodesindex(
    ena::MINDFul.EndNodeAllocations
) -> Union{Nothing, Int64}

gettransmissionmodesindex(
    ena::MINDFul.MutableEndNodeAllocations
) -> Union{Nothing, Int64}

gettransmissionmodesindex(
    s::MINDFul.TransmissionModuleLLI
) -> Int64

gettransmissionmodule(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    oxclli::MINDFul.TransmissionModuleLLI
) -> MINDFul.TransmissionModuleView

gettransmissionmodule(
    ibnf::MINDFul.IBNFramework,
    intent::MINDFul.TransmissionModuleLLI
) -> MINDFul.TransmissionModuleView

Get the transmission mode

gettransmissionmodulecompat(
    oic::MINDFul.OpticalInitiateConstraint
) -> MINDFul.TransmissionModuleCompatibility

gettransmissionmodulereservations(
    s::MINDFul.NodeView
) -> Dict{Base.UUID, MINDFul.TransmissionModuleLLI}

gettransmissionmoduleviewpool(
    s::MINDFul.NodeView
) -> Union{Nothing, Vector{T}} where T<:MINDFul.TransmissionModuleView

gettransmissionmoduleviewpoolindex(
    ena::MINDFul.EndNodeAllocations
) -> Union{Nothing, Int64}

gettransmissionmoduleviewpoolindex(
    ena::MINDFul.MutableEndNodeAllocations
) -> Union{Nothing, Int64}

gettransmissionmoduleviewpoolindex(
    s::MINDFul.TransmissionModuleLLI
) -> Int64

getunderlyingequipment(
    s::MINDFul.TransmissionModuleView
) -> MINDFul.AbstractTransmissionModule

getweights(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView
) -> Matrix

addintent!(
    ibnf::MINDFul.IBNFramework,
    intent::MINDFul.AbstractIntent,
    intentissuer::MINDFul.IntentIssuer;
    offsettime
) -> MINDFul.ReturnUUIDTime

using Base: source_path kk Add a new user intent to the IBN framework and return the id.

compileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime

THIS SHOULD BE THE ENTRY FUNCTION. DO NOT USE DIRECTLY THE idagnode ONES.

compileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.LightpathIntent};
    verbose,
    offsettime
) -> Symbol

compileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ProtectedLightpathIntent};
    verbose,
    offsettime
) -> Symbol

compileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.RemoteIntent};
    verbose,
    offsettime
) -> Any

compileintent!(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestAverageEmpiricalAvailabilityCompilation},
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent};
    verbose,
    offsettime
) -> Symbol

compileintent!(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestEmpiricalAvailabilityCompilation},
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent};
    verbose,
    offsettime
) -> Symbol

compileintent!(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.KShorestPathFirstFitCompilation},
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent};
    verbose,
    offsettime
) -> Symbol

findindexglobalnode(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    globalnode::MINDFul.GlobalNode
) -> Union{Nothing, Int64}

Convenience function that returns the findfirst for the global node

installintent!(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime

isbordernode(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    localnode::Int64
) -> Bool

Return boolean if localnode is in ibnf as a border node

isbordernode(
    ibnf::MINDFul.IBNFramework,
    localnode::Int64
) -> Any

Return boolean if localnode is in ibnf as a border node

isbordernode(
    ibnf::MINDFul.IBNFramework,
    globalnode::MINDFul.GlobalNode
) -> Any

Return boolean if globalnode is in ibnf as a border node

isinternalnode(
    ibnf::MINDFul.IBNFramework,
    globalnode::MINDFul.GlobalNode
) -> Bool

Return boolean if globalnode belongs to ibnf

remoteintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode,
    remoteibnfid::Base.UUID;
    offsettime
) -> MINDFul.IntentDAGNode{I, MINDFul.MachineGenerated} where I<:MINDFul.RemoteIntent

Add a RemoteIntent as a child intent and delegate it to the ibn with id remoteibndif

removeintent!(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime

uncompileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime

uninstallintent!(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    forceinstallable,
    offsettime
) -> MINDFul.ReturnCodeTime

All possible default intent states. Another intent state schema could be defined.

The return codes defined for functions to give back explaining the situation. Mostly used for the compilation of an intent. All the const variables have a Symbol value that is the same as the variable name but only the first letter capitalized.

Signifies generic failure

Not appropriate candidate paths

Destination OXC Add/Drop port not found

No available router ports were found in destination node

Destination transmission module not found

Used a remote intent to groom and that remote intent state was not installed or compiled

No available connection for the given optical reach was found

No available connection for the given optical reach, coming from an initiate optical constraint, was found

No available connection for the given optical reach, coming from an initiate optical constraint, was found

No available connection for the given optical reach, coming from an initiate optical constraint, was found even after retrying/recompiling

The same OXC LLI trying to be allocated already exists

No available spectrum was found

No available connection for the specturm slots, coming from an initiate optical constraint, was found

Source OXC Add/Drop port not found

No available router ports were found in source node

Source transmission module not found

Signifies everything worked as planned

The HTTP codes and data defined for the different requests. All the const variables have a String value that represents the endpoint of the URL or the data that is passed respectively. With full permission, the domains can access all the functions of the remote IBN framework. With limited permission, the domains can only access the defined limited set of functions.

The type of the HTTP server used in the IBN Framework depends on whether the encryption is used or not.

A handler or API for IBNFrameworks to talk to each other

abstract type AbstractIntent

A concrete subtype of AbstractIntent must implement the following methods:

• is_low_level_intent

Special requirements for an intent (such as QoS)

How the IBN frameworks operates generally. It has effect of the available compilation algorithms In the future it could also have effect on different intent state machines

The abstract type of the SDN controllers

struct AvailabilityConstraint <: MINDFul.AbstractIntentConstraint

• availabilityrequirement::Float64: A float between 0 and 1 for the desired availability

• compliancetarget::Float64: A float between 0 and 1 expressing the desired probability to cover the availability requirement

mutable struct BasicAlgorithmMemory

• datetime::Dates.DateTime: The simulated (or not) current datetime. It's used by the algorithm to build the uptime/downtime data

• logintrapaths::Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Dict{Vector{Vector{Int64}}, Int64}}: Log here the selection of (protection) path for an intra node (+ border) intent after install. Add new elements upon installation A new path Vector{Vector{LocalNode}} is added per node pair and counted how many times was it used

• loginterupdowntimes::Dict{MINDFul.GlobalEdge, Dict{Base.UUID, MINDFul.ConnectionData}}: Log here the up/downtimes of border-node to cross node. Add new elements upon installation. Update entries upon compilation. All UUIDs correspond to Remote Connectivity intents

mutable struct BestAverageEmpiricalAvailabilityCompilation <: MINDFul.IntentCompilationAlgorithmWithMemory

• candidatepathsnum::Int64: How many k paths to check

• pathsforprotectionnum::Int64: How many m paths to consider for joint protection. It investigates all possible pair of the first m paths

• cachedresults::MINDFul.CachedResults: cached information

• basicalgmem::MINDFul.BasicAlgorithmMemory: The algorithm memory that is updated

mutable struct BestEmpiricalAvailabilityCompilation <: MINDFul.IntentCompilationAlgorithmWithMemory

• candidatepathsnum::Int64: How many k paths to check

• pathsforprotectionnum::Int64: How many m paths to consider for joint protection. It investigates all possible pair of the first m paths

• cachedresults::MINDFul.CachedResults: cached information

• basicalgmem::MINDFul.BasicAlgorithmMemory: The algorithm memory that is updated

Stores a vector of the history of the boolean states and their timings

struct CachedResults

• ibnagweights::Matrix{Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}}

• yenpathsdict::Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Vector{Int64}}}

• yenpathsdistsdict::Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}}}

Used for every intent compilation algorithm satisfying the template to cache and not recalculate results.

struct ConnectivityIntent{T<:MINDFul.AbstractIntentConstraint} <: MINDFul.AbstractIntent

• sourcenode::MINDFul.GlobalNode: Source node

• destinationnode::MINDFul.GlobalNode: Destination node

• rate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}: Bandwidth request value (Gbps)

• constraints::Vector{T} where T<:MINDFul.AbstractIntentConstraint: Constraints for the Connecivity intent

• servicetime::Union{Nothing, Float64}: Time in hours on nothing

struct CrossLightpathIntent{C1<:MINDFul.ConnectivityIntent, C2<:MINDFul.ConnectivityIntent} <: MINDFul.AbstractIntent

• lightpathconnectivityintent::MINDFul.ConnectivityIntent

• remoteconnectivityintent::MINDFul.ConnectivityIntent

The only intent that is being built from its children to be offered as a straight grooming possibility. It is composed by a LightpathIntent and a RemoteIntent which are also its children intents.

Default operation mode defined in MINDFul.jl

struct EdgeProperties

• distance::Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}: The distance of the edge (assumed km)

An immutable description of the edge properties

struct EdgeView

• edgeproperties::MINDFul.EdgeProperties: The EdgeProperties

The view of the current edge settings

struct EndNodeAllocations

• localnode::Int64

• routerportindex::Union{Nothing, Int64}

• transmissionmoduleviewpoolindex::Union{Nothing, Int64}

• transmissionmodesindex::Union{Nothing, Int64}

• localnode_input::Union{Nothing, Int64}

• adddropport::Union{Nothing, Int64}

Basically an aggregator of RouterPortLLI, TransmissionModuleLLI, OXCAddDropBypassSpectrumLLI in a node.

struct GlobalNode

• ibnfid::Base.UUID: IBN Framework id

• localnode::Int64: Node number

The graph of the IBN Framework is expressed with this `AttributeGraph`.
Border nodes are assumed to be visible from both sides.
However only the official owner can issue an intent.

mutable struct IBNFCommunication{H<:MINDFul.AbstractIBNFHandler}

• server::Union{Nothing, HTTP.Servers.Server{HTTP.Servers.Listener{Nothing, Sockets.TCPServer}}, HTTP.Servers.Server{HTTP.Servers.Listener{MbedTLS.SSLConfig, Sockets.TCPServer}}}

• ibnfhandlers::Vector{H} where H<:MINDFul.AbstractIBNFHandler

Server is of type Union{Nothing, OxygenServer} to allow for the server to be started later.

struct IBNFramework{O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.IntentCompilationAlgorithm} <: MINDFul.AbstractIBNFHandler

• operationmode::MINDFul.AbstractOperationMode: The operation mode of the IBN framework

• ibnfid::Base.UUID: The id of this IBN Framework instance

• intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}: The intent dag tree that contains all intents (can be disconnected graph)

• ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView: Single-domain internal graph with border nodes included

• ibnfcomm::MINDFul.IBNFCommunication: Other IBN Frameworks handles

• sdncontroller::MINDFul.AbstractSDNController: SDN controller handle

• intcompalg::MINDFul.IntentCompilationAlgorithm: Intent compilation algorithm

IBNFramework(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    ibnfhandlers::Array{H<:MINDFul.AbstractIBNFHandler, 1},
    encryption::Bool,
    ips::Vector{String},
    sdncontroller::MINDFul.AbstractSDNController,
    intcompalg::MINDFul.IntentCompilationAlgorithm;
    ...
) -> MINDFul.IBNFramework{MINDFul.DefaultOperationMode}
IBNFramework(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    ibnfhandlers::Array{H<:MINDFul.AbstractIBNFHandler, 1},
    encryption::Bool,
    ips::Vector{String},
    sdncontroller::MINDFul.AbstractSDNController,
    intcompalg::MINDFul.IntentCompilationAlgorithm,
    ibnfsdict::Dict{Int64, MINDFul.IBNFramework};
    verbose
) -> MINDFul.IBNFramework{MINDFul.DefaultOperationMode}

Constructor that specify IBNFHandlers to make it potentially type stable

IBNFramework(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    intcompalg::MINDFul.IntentCompilationAlgorithm
) -> MINDFul.IBNFramework{MINDFul.DefaultOperationMode, MINDFul.SDNdummy, T, I} where {T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:(MINDFul.IBNFCommunication{H} where H<:(MINDFul.IBNFramework{MINDFul.DefaultOperationMode, MINDFul.SDNdummy}))}

The most default construct with abstract type of IBN handlers

struct IBNIssuer <: MINDFul.IntentIssuer

Intent is issued by an IBN Framework domain

• ibnfid::Base.UUID: the id of the IBNF issued the intent

• idagnodeid::Base.UUID: The id of the intent node in the DAG. The issuer of this intent node points back in this IBNIssuer instance.

Instances of this specify how to compile the intent

Compilation algorithm with some memory

An AttributeGraph graph used as an intent Directed Acyclic Graph (DAG)

mutable struct IntentDAGInfo

• intentcounter::Int64: The counter of the number of intents to give increasing ids to intents

• installedlightpaths::Dict{Base.UUID, MINDFul.LightpathRepresentation}: Logical representation of the installed intents as lightpaths (must be direct parent of the LLIs)

• idagnodeidxdict::Dict{Base.UUID, Int64}: Dict to find the idx of a specific intent. For performance purposes

IntentDAGInfo() -> MINDFul.IntentDAGInfo

Empty constructor

struct IntentDAGNode{I<:MINDFul.AbstractIntent, II<:MINDFul.IntentIssuer}

• intent::MINDFul.AbstractIntent: The intent itself

• idagnodeid::Base.UUID: The id of the intent w.r.t. the intent DAG it belongs

• intentissuer::MINDFul.IntentIssuer: The intent issuer

• logstate::Vector{Tuple{Dates.DateTime, MINDFul.IntentState.T}}: The history of states of the intent with the last being the current state

Characterizes the entity issuing an intent

IntentLogState(

) -> Vector{Tuple{Dates.DateTime, MINDFul.IntentState.T}}
IntentLogState(
    intentstate::MINDFul.IntentState.T
) -> Vector{Tuple{Dates.DateTime, MINDFul.IntentState.T}}
IntentLogState(
    intentstate::MINDFul.IntentState.T,
    logtime::Dates.DateTime
) -> Vector{Tuple{Dates.DateTime, MINDFul.IntentState.T}}

Stores a vector of the history of the intent states and their timings

Stores a single log element for the intent state and time

struct KShorestPathFirstFitCompilation <: MINDFul.IntentCompilationAlgorithmWithMemory

• candidatepathsnum::Int64: How many k paths to check

• cachedresults::MINDFul.CachedResults

• basicalgmem::MINDFul.BasicAlgorithmMemory

Cannot handle AvailabilityConstraints and will fail with weird error

KShorestPathFirstFitCompilation(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    candidatepathnum::Int64
) -> MINDFul.KShorestPathFirstFitCompilation

struct LightpathIntent <: MINDFul.AbstractIntent

• sourcenodeallocations::MINDFul.EndNodeAllocations

• destinationnodeallocations::MINDFul.EndNodeAllocations

• spectrumslotsrange::UnitRange{Int64}

• path::Vector{Int64}

Basicaly an aggregator of LowLevelIntents. One lightpath intent can translate trivially to LowLevelIntents. It's core use is for grooming, where several Connectivity Intents can be linked to one LightpathIntent If the field does not apply, put 0

struct LightpathRepresentation

• path::Vector{Vector{Int64}}: The nodes comprising the lightpath

• startsoptically::Bool: true if it starts optically (due to OpticalInitiateConstraint) or false otherwise

• terminatessoptically::Bool: true if it terminates optically (due to OpticalTerminateConstraint) or false otherwise

• totalbandwidth::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}: total bandwidth that can be allocated

• destinationnode::MINDFul.GlobalNode: final node of the signal entering this lightpath. This could be a GlobalNode intrnally in the domain for a single lightpath. Or an external GlobalNode in a different domain for a cross-lightpath. In the second case, the signal might go over different lightpaths to reach the destination.

Represents an implementation of a ConnectivityIntent as a lightpath

struct LimitedSplitConstraint <: MINDFul.AbstractIntentConstraint

Constraint that obliges no limitless splitting of the intent Split level is 0 in root intent and increases +1 for every child Splitting in border node doesn't count as it's necessary.

Signifies a local node notation as a single integer

abstract type LowLevelIntent <: MINDFul.AbstractIntent

An abstract subtype of AbstractIntent notating device-level intents and should return is_low_level_intent to be true

Intent is generated automatically by the IBN Framework

Intent issued directly by the network operator, i.e., a user intent

struct NoGroomingConstraint <: MINDFul.AbstractIntentConstraint

Constraint that requires the intent is compiled without use of grooming techniques.

struct NodeProperties

• localnode::Int64

• globalnode::MINDFul.GlobalNode

• latitude::Float64

• longitude::Float64

• inneighbors::Vector{Int64}: The list of neighbohrs coming in

• outneighbors::Vector{Int64}: The list of neighbohrs going out

An immutable description of the node properties

struct NodeView{R<:MINDFul.RouterView, O<:MINDFul.OXCView, T<:MINDFul.TransmissionModuleView} <: MINDFul.ReservableResourceView

• nodeproperties::MINDFul.NodeProperties: The NodeProperties

• routerview::Union{Nothing, R} where R<:MINDFul.RouterView: The router in use

• oxcview::Union{Nothing, O} where O<:MINDFul.OXCView: The OXC in use

• transmissionmoduleviewpool::Union{Nothing, Vector{T}} where T<:MINDFul.TransmissionModuleView: The transmission modules contained

• transmissionmodulereservations::Union{Nothing, Dict{Base.UUID, MINDFul.TransmissionModuleLLI}}: intent reservation of the transmission modules

• transmissionmodulestaged::Union{Nothing, Set{MINDFul.TransmissionModuleLLI}}: intent staged of the transmission modules

The view of the current node settings Reservables resources reservations are nothing if it represents a border node.

struct OXCAddDropBypassSpectrumLLI <: MINDFul.LowLevelIntent

• localnode::Int64: Target node

• localnode_input::Int64: The node in graph entering the OXC (or 0 if invalid)

• adddropport::Int64: The port index adding or dropping an optical signal (or 0 if invalid)

• localnode_output::Int64: The node in graph exiting the OXC (or 0 if invalid)

• spectrumslotsrange::UnitRange{Int64}: The spectrum range allocated 1-based indexed

A value-based interpretation of (input, adddrop, output). At least one of the 3 elements must be 0. (x, 0, y) means optical bypass from the localnode x to the localnode y (0, x, y) means adding an optical signal from add port x going to the localnode y (x, y, 0) means droping an optical signal from the localnode x to the drop port y (0, x, 0) mean that an add/drop allocation port is only reserved (is needed on top for an add/drop signal)

struct OXCView{O<:MINDFul.AbstractOXC} <: MINDFul.ReservableResourceView

• oxc::MINDFul.AbstractOXC: the underlying OXC

• adddropportnumber::Int64: The number of add/drop ports in OXC

• switchreservations::Dict{Base.UUID, MINDFul.OXCAddDropBypassSpectrumLLI}: The intent reservations together with the configuration

• switchstaged::Set{MINDFul.OXCAddDropBypassSpectrumLLI}: The intent staged together with the configuration

• linkspectrumavailabilities::Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Bool}}: Link spectrum availability total view in sync with switchreservations. A vector showing the availability of the spectrum slots. true for available and false for reserved. The vector views should be the same with the ones on the opposite OXC view.

• linkstates::Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Tuple{Dates.DateTime, Bool}}}: History information of the status of the connected links (working or not). The last element is the current state.

A view of a OXC. This OXC view is also a view to the links connecting to the OXC. Since links are not devices under control, MINDFul does not model them directly.

struct OpticalInitiateConstraint <: MINDFul.AbstractIntentConstraint

Constraint that requires the intent to initiate optically. It's combined with an (@ref)[OpticalTerminateConstraint] before. It contains some requirements for the connection to work out.

• globalnode_input::MINDFul.GlobalNode: The incoming border node entering the OXC

• spectrumslotsrange::UnitRange{Int64}: The spectrum range allocated 1-based indexed

• opticalreach::Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}: the remaining optical reach to use

• transmissionmodulecompat::MINDFul.TransmissionModuleCompatibility: Requirements for termination in the electical layer

struct OpticalTerminateConstraint <: MINDFul.AbstractIntentConstraint

Constraint that requires the intent to terminate optically one node before the destination. It's combined with an (@ref)[OpticalInitiateConstraint] after.

• finaldestination::MINDFul.GlobalNode: The final destination (intra domain or inter-domain) Used primarily for grooming cross lightpaths.

struct ProtectedLightpathIntent <: MINDFul.AbstractIntent

• prsourcenodeallocations::Vector{MINDFul.EndNodeAllocations}

• prdestinationnodeallocations::Vector{MINDFul.EndNodeAllocations}

• prspectrumslotsrange::Vector{UnitRange{Int64}}

• prpath::Vector{Vector{Int64}}

An accumulation of lightpaths such that they get protected It's being translated down to many Lightpath intents that have certain LLIs groomed with one another Furthermore, only one lightpath is installed and the others are staged. In case of a failure a different working lightpath will be installed instead

mutable struct RemoteHTTPHandler <: MINDFul.AbstractIBNFHandler

• ibnfid::Base.UUID

• baseurl::String

• permission::String

• rsakey::String

• rsasecret::String

• gentoken::String

• recvtoken::String

A single token is generated per directed pair. The permission is referring to the genenerated token (gentoken). gentoken and recvtoken are not constant as they will be generated when the handshake is done. rsakey contains the private key if the handler belongs to the local domain. If the handler is for a remote domain, it contains the public key of that domain. The secret is used to authenticate the initiator domain and it is also generated during the handshake.

struct RemoteIntent{I<:MINDFul.AbstractIntent} <: MINDFul.AbstractIntent

• ibnfid::Base.UUID: The id of the remote IBN framework

• idagnodeid::Base.UUID: The dag node id of the remote IBN framework

• intent::MINDFul.AbstractIntent: The intent to be transferred

• isinitiator::Bool: true if the intent originates here and false otherwise

The following functions should be implemented for subtypes:

• getreservations(subtype::ReservableResourceView)::Set{T}
• canreserve(subtype::ReservableResourceView, reservation::T)::Bool

The following default functions exist that should already work

• reserve!(subtype::ReservableResourceView, dagnodeid::UUID, reservation::T; checkfirst::Bool=true)::Bool
• unreserve!(subtype::ReservableResourceView, dagnodeid::UUID)::Bool
• insertreservation!(subtype::ReservableResourceView, dagnodeid::UUID, reservation::T)
• deletereservation!(subtype::ReservableResourceView, dagnodeid::UUID)

struct ReturnCodeTime

• returncode::Symbol

• datetime::Dates.DateTime

What most time-sensitive functions return

struct ReturnUUIDTime

• uuid::Base.UUID

• datetime::Dates.DateTime

struct RouterPort

A representation of a router port.

• rate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}

struct RouterPortLLI <: MINDFul.LowLevelIntent

• localnode::Int64: Target node

• routerportindex::Int64: The router port index to be reserved

struct RouterView{R<:MINDFul.AbstractRouter} <: MINDFul.ReservableResourceView

A view of a router with several ports.

• router::MINDFul.AbstractRouter: The underlying router

• ports::Vector{MINDFul.RouterPort}: number of ports in router

• portreservations::Dict{Base.UUID, MINDFul.RouterPortLLI}: The intent reservations together with the low level intent of reserved port

• portstaged::Set{MINDFul.RouterPortLLI}: The intent reservations together with the low level intent of a staged port

struct SDNdummy <: MINDFul.AbstractSDNController

struct SplitGlobalNode

• globalnode::MINDFul.GlobalNode

• firsthalfavailabilityconstraint::Union{Nothing, MINDFul.AvailabilityConstraint}

• secondhalfavailabilityconstraint::Union{Nothing, MINDFul.AvailabilityConstraint}

The return value from the prioritizesplitnode and prioritizesplitbordernode functions

SplitGlobalNode(
    globalnode::MINDFul.GlobalNode
) -> MINDFul.SplitGlobalNode

struct TransmissionMode

Represents a transmission mode. A transponder, if flexible, might support many of them.

• opticalreach::Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}: Optical reach in kilometers

• rate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}: rate in Gbps

• spectrumslotsneeded::Int64: Number of 12.5 GHz frequency slots needed

struct TransmissionModuleCompatibility

• routerportrate::Union{Nothing, Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}}: The router port rate (maximum). If it's nothing it means it's already resolved and trusted.

• rate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}: The bandwidth of the connection

• spectrumslotsneeded::Int64: Number of 12.5Gz frequency slots needed

• name::String: descriptive name of the transmission module

Describe what requirements are needed to establish transmission module end-to-end connection Modulation should be here but it's not. Dissagregetation data should be here but it's not. Both are covered by the name which must be equal in both ends

struct TransmissionModuleIntent <: MINDFul.AbstractIntent

Contains the requirements to compile down to TransmissionModuleLLI

• rate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}: The data rate requierement

• opticalreach::Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}: Optical reach requirements in kilometres

• spectrumslotsneeded::Int64: Number of 12.5 GHz frequency slots needed

struct TransmissionModuleLLI <: MINDFul.LowLevelIntent

• localnode::Int64: Target node

• transmissionmoduleviewpoolindex::Int64: The index of the transmission module pool to be reserved

• transmissionmodesindex::Int64: The selected mode of the transmission module. 0 means nothing is still selected. Non elastic modules can have only 1.

• routerportindex::Int64: The router port index to be connected

• adddropport::Int64: The port index adding or dropping the optical signal to be connected

struct TransmissionModuleView{T<:MINDFul.AbstractTransmissionModule}

• transmissionmodule::MINDFul.AbstractTransmissionModule: The underlying transmission module

• name::String: descriptive name of the transmission module

• transmissionmodes::Vector{MINDFul.TransmissionMode}: operating transmission modes

• cost::Float64: Cost of the transmission module (in unit costs)

A view of a transmission module.

show(io::IO, ibnf::MINDFul.IBNFramework)

_rec_deletenodesedgesuntilgroomingfound!(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID,
    idagnodeid2dlt::Vector{Base.UUID}
) -> Bool

Returns true if grooming is found and the idagnodeid to delete

addidagedge!(
    ibnf::MINDFul.IBNFramework,
    fromnode::Base.UUID,
    tonode::Base.UUID;
    offsettime
) -> Bool

addidagnode!(
    ibnf::MINDFul.IBNFramework,
    intent::MINDFul.AbstractIntent;
    parentids,
    childids,
    intentissuer,
    offsettime
) -> MINDFul.IntentDAGNode{I, MINDFul.MachineGenerated} where I<:MINDFul.AbstractIntent

Return the IntentDAGNode

addidagnode!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode;
    parentids,
    childids,
    intentissuer
) -> Base.UUID

Return the UUID

addkeywordparameters!(
    funcexpr::Expr,
    keywordparexprs::Expr...
) -> Expr

addtoinstalledlightpaths!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent}
) -> Bool

If idagnode represents a direct parent of LLIs that are a lightpath, add representation to the IntentDAGInfo Return true if done. Otherwise false

addtoinstalledlightpaths!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{MINDFul.LightpathIntent}
) -> Bool

If idagnode represents a direct parent of LLIs that are a lightpath, add representation to the IntentDAGInfo Return true if done. Otherwise false

addtoinstalledlightpaths!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{MINDFul.ProtectedLightpathIntent}
) -> Bool

allocate_oxcspectrumslots(
    ibnf::MINDFul.IBNFramework,
    dagnodeid::Base.UUID,
    localnode::Int64
) -> Bool

allocate_transmissionmodule(
    ibnf::MINDFul.IBNFramework,
    dagnodeid::Base.UUID,
    localnode::Int64,
    transmissionmodulereservationentry::MINDFul.TransmissionModuleLLI
)

aretransmissionmodulescompatible(
    tmv1::MINDFul.TransmissionModuleView,
    tmv2::MINDFul.TransmissionModuleView
) -> Bool

Almost same code as calcintrasplitglobalnode

calcintrasplitglobalnode(
    ibnf::MINDFul.IBNFramework,
    intent::MINDFul.ConnectivityIntent,
    splitglobalnodeonly::MINDFul.GlobalNode
) -> MINDFul.SplitGlobalNode

calcsecondhalfavailabilityconstraint(
    ibnf::MINDFul.IBNFramework,
    firsthalfavailability::Float64,
    masteravconstr::MINDFul.AvailabilityConstraint
) -> MINDFul.AvailabilityConstraint

After estimateintentavailability(IBNFramework, ::IntentDAGNode{<:ConnectivityIntent}) is invoked for the first half of the internal intent, this function is called to get back the right AvailabilityConstraint to ask for

Must always return a AvailabilityConstraint

Assumes 100% compliance target

The firsthalfavailability must be of the same type that the estimateintentavailability returns.

calcsecondhalfavailabilityconstraint(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestAverageEmpiricalAvailabilityCompilation},
    firsthalfavailability::Distributions.DiscreteNonParametric,
    masteravconstr::MINDFul.AvailabilityConstraint
) -> MINDFul.AvailabilityConstraint

Must always return a AvailabilityConstraint

Assumes equal compliance target split

calcsecondhalfavailabilityconstraint(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestEmpiricalAvailabilityCompilation},
    firsthalfavailability::Distributions.DiscreteNonParametric,
    masteravconstr::MINDFul.AvailabilityConstraint
) -> MINDFul.AvailabilityConstraint

Must always return a AvailabilityConstraint

Assumes equal compliance target split

calcsecondhalfavailabilityconstraint_defaultstochastic(
    ibnf::MINDFul.IBNFramework,
    firsthalfavailability,
    masteravconstr::MINDFul.AvailabilityConstraint
) -> MINDFul.AvailabilityConstraint

Implements calcsecondhalfavailabilityconstraint

Assumes equal compliance target split

calculatepathavailability(
    availabilities::Vector{Float64}
) -> Float64

calculateprotectedpathavailability(
    p1edges::Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}},
    p1avails::Vector{Float64},
    p2edges::Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}},
    p2avails::Vector{Float64}
) -> Float64

calculateprotectedpathavailability(
    p1edges::Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}},
    p1avails::Vector{Vector{Float64}},
    p2edges::Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}},
    p2avails::Vector{Vector{Float64}}
) -> Vector{Float64}

For MCMC Chain availabilities

calculateprotectedpathavailability(
    pedges::Vector{Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}}},
    pavails::Vector{Vector{Float64}}
) -> Float64

need to finish it if I ever use more than 2 protection paths

canreserve(
    sdn::MINDFul.AbstractSDNController,
    nodeview::MINDFul.NodeView,
    transmissionmodulelli::MINDFul.TransmissionModuleLLI;
    verbose
) -> Bool

Set verbose=true to see where the reservation fails

canreserve(
    sdn::MINDFul.AbstractSDNController,
    oxcview::MINDFul.OXCView,
    oxcswitchreservationentry::MINDFul.OXCAddDropBypassSpectrumLLI;
    verbose
) -> Bool

Check whether

• add/drop port exists
• add/drop port already in use
• spectrum in fibers in use

Set verbose=true to see where the reservation fails

canreserve(
    sdn::MINDFul.AbstractSDNController,
    routerview::MINDFul.RouterView,
    routerportlli::MINDFul.RouterPortLLI;
    verbose
) -> Bool

Check if router port exists and whether it is already used

Set verbose=true to see where the reservation fails

checkfilepath(
    directoryname::String,
    filepath::String
) -> String

Function to check if a given file path is absolute or relative. If it is relative, it will be joined with the given directory name.

checkifopensslinstalled() -> Bool

Function to check if openSSL is installed on the system. It runs the openssl version command and checks if it succeeds. If it fails, it prints an error message and exits.

choosecrosssplitavailabilities(
    avcon::MINDFul.AvailabilityConstraint,
    firsthalfavailability,
    secondhalfavailability,
    beacomp::MINDFul.BestAverageEmpiricalAvailabilityCompilation
) -> Tuple{MINDFul.AvailabilityConstraint, MINDFul.AvailabilityConstraint}

choosecrosssplitavailabilities(
    avcon::MINDFul.AvailabilityConstraint,
    firsthalfavailability,
    secondhalfavailability,
    beacomp::MINDFul.BestEmpiricalAvailabilityCompilation
) -> Tuple{MINDFul.AvailabilityConstraint, MINDFul.AvailabilityConstraint}

choosecrosssplitavailabilities(
    avcon::MINDFul.AvailabilityConstraint,
    firsthalfavailability,
    secondhalfavailability,
    intentcomp::MINDFul.IntentCompilationAlgorithm
) -> Tuple{MINDFul.AvailabilityConstraint, MINDFul.AvailabilityConstraint}

chooseintrasplitavailabilities(
    avcon::MINDFul.AvailabilityConstraint,
    firsthalfavailability,
    secondhalfavailability,
    intentcomp::MINDFul.IntentCompilationAlgorithm
) -> Tuple{MINDFul.AvailabilityConstraint, MINDFul.AvailabilityConstraint}

After calculating the two halfs of the availabilities, choose the two availabilities.

chooseintrasplitavailabilities(
    avcon::MINDFul.AvailabilityConstraint,
    firsthalfavailability::Distributions.DiscreteNonParametric,
    secondhalfavailability::Distributions.DiscreteNonParametric,
    beacomp::MINDFul.BestEmpiricalAvailabilityCompilation
) -> Tuple{MINDFul.AvailabilityConstraint, MINDFul.AvailabilityConstraint}

quantile(::DiscreteNonParametric, q) gives smallest value x such that cdf(::DiscreteNonParatetric, x) >= q This means that there is x is the biggest value for q% of ::DiscreteNonParametric. For example, q=0.95 means that x will be bigger than 95% of the support of ::DiscreteNonParametric. cquantile is exactly the opposite implying that it would be smaller than 95% of the support. For example, now talking availability requirements and compliance targets,

chooseintrasplitavailabilities_defaultstochastic(
    avcon::MINDFul.AvailabilityConstraint,
    firsthalfavailability,
    secondhalfavailability,
    intcomp::MINDFul.IntentCompilationAlgorithm
) -> Tuple{MINDFul.AvailabilityConstraint, MINDFul.AvailabilityConstraint}

Implements chooseintrasplitavailabilities.

quantile(::DiscreteNonParametric, q) gives smallest value x such that cdf(::DiscreteNonParatetric, x) >= q This means that there is x is the biggest value for q% of ::DiscreteNonParametric. For example, q=0.95 means that x will be bigger than 95% of the support of ::DiscreteNonParametric. cquantile is exactly the opposite implying that it would be smaller than 95% of the support. For example, now talking availability requirements and compliance targets,

chooseoxcadddropport_first(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64
) -> Union{Nothing, Int64}

Return the uniformly random available oxc add/drop port and nothing if none found

choosespectrum_firstfit(
    ibnf::MINDFul.IBNFramework,
    pathspectrumavailability::AbstractVector{Bool},
    demandslotsneeded::Int64
) -> Union{Nothing, Int64}

choosespectrum_firstfit(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    path::Vector{Int64},
    demandslotsneeded::Int64
) -> Union{Nothing, Int64}

closeibnfserver(ibnf::MINDFul.IBNFramework)

Function to gracefully close the server of an IBNFramework.

compilegroomingpossibility(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    groomingpossibility::Vector{Union{Base.UUID, Graphs.SimpleGraphs.SimpleEdge{Int64}}},
    intradomainalgfun::Function,
    cachedintentresult::Dict{MINDFul.ConnectivityIntent, Symbol};
    verbose,
    offsettime
) -> Symbol

Returns ReturnCode on whether it managed to compile the grooming possibility passed.

compileintenttemplate!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent};
    verbose,
    intradomainalgfun,
    prioritizesplitnodes,
    prioritizesplitbordernodes,
    cachedintentresult,
    maximumsplitlevel,
    offsettime
)

A template compilation function that can be extended

Give in the following hook functions:

• intradomainalgfun is used as compilation algorithm for the intents handled internally.

It should return a Symbol as a return code. Common return codes are found in MINDFul.ReturnCodes. This function is generated using MINDFul.intradomaincompilationtemplate

intradomainalgfun(
    ibnf::IBNFramework, 
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    cachedintentresult::Dict{ConnectivityIntent, Symbol},
    ; datetime::DateTime
) -> Symbol

• prioritizesplitnodes is called when optical reach is not enough to have a lightpath end-to-end to serve the intent. The node selected will break the intent into two pieces with the node standing in between.

This function should return a vector of SplitGlobalNodes with decreasing priority of which node should be chosen. The same split node might be returned multiple times, but with different availability requirements.

prioritizesplitnodes(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode,
) -> Vector{SplitGlobalNode}

• prioritizesplitbordernodes is called to select the border node to work as the source node for the delegated intent in a neighboring domain.

This function should return a vector of SplitGlobalNodes with decreasing priority of which node should be chosen. The same split node might be returned multiple times, but with different availability requirements.

prioritizesplitbordernodes(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
) -> Vector{GlobalNode}

- `cachedintentresult` are the cached `ResultCode` per intent considered.

- `maximumsplitlevel` is the maximum times an intent will be split with `prioritizesplitnodes`

Pass a `Vector{Vector{Int}}` where `Int` are the nodes of each lightpath.
Return a `Vector{Vector{Int}}` where `Int` is the index of the contained lightpaths.
if `startingnode = true`, `node` is starting else is ending.

julia> MINDF.consecutivelightpathsidx([
       [1,3,7], #1
       [2,5,7], #2
       [2,8,9], #3
       [7,4,2]
       ], 1; startingnode=true)
3-element Vector{Vector{Int64}}:
 [1]
 [1, 4]
 [1, 4, 3]

Return all possible combination of the lightpath indices passed such that `path` is formed

construct_BoolLogState(

) -> Vector{Tuple{Dates.DateTime, Bool}}
construct_BoolLogState(
    offsettime
) -> Vector{T} where T<:Tuple{Any, Bool}
construct_BoolLogState(
    offsettime,
    initialstate
) -> Vector{<:Tuple{Any, Any}}

Implementing BoolLogState() is type piracy.

constructfromdict(
    _::Type{T},
    dict::Dict{Symbol},
    dict2::Dict{Symbol}
) -> MINDFul.NodeProperties

Convenience function to construct any struct of type T by passing a Dict corresponding to the fields needed. A further dict dict2 is searched for data.

constructfromdict(
    _::Type{T},
    dict::Dict{Symbol}
) -> MINDFul.EdgeProperties

using Core: ReturnNode

Convenience function to construct any struct of type T by passing a Dict corresponding to the fields needed.

convertb64keytopem(
    keyb64::String,
    typeofkey::String
) -> String

Function to convert a base64 encoded key to PEM format. The typeofkey parameter should be either "PUBLIC KEY" or "PRIVATE KEY".

createmultidomainIBNAttributeGraph(
    ibnf::MINDFul.IBNFramework
) -> AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView

Construct a IBNAttributeGraph representation for all mutli-domain network from the IBNFramework neighboring interIBNF ATTENTION: the inner graph data are still representing information internally per domain.

deallocate_transmissionmodule(
    ibnf::MINDFul.IBNFramework,
    localnode::Int64,
    transmissionmodulereservationentry::MINDFul.TransmissionModuleLLI
) -> Bool

default_OXCview(
    nodeproperties::MINDFul.NodeProperties,
    spectrumslots::Int64
) -> MINDFul.OXCView{MINDFul.OXCDummy}
default_OXCview(
    nodeproperties::MINDFul.NodeProperties,
    spectrumslots::Int64,
    offsettime
) -> MINDFul.OXCView{MINDFul.OXCDummy}

deleteedgesuntilgroomingfound!(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
)

Delete edges towards grooming nodes.

deletenodesedgesuntilgroomingfound(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
)

Delete all nodes and edges until the grooming node is found. If no grooming node is found, delete nothing. Start from idagnodeid

deletereservation!(
    sdn::MINDFul.AbstractSDNController,
    resourceview::MINDFul.ReservableResourceView,
    dagnodeid::Base.UUID;
    verbose
)

deletereservationhook!(
    sdn::MINDFul.AbstractSDNController,
    oxcview::MINDFul.OXCView,
    dagnodeid::Base.UUID;
    verbose
) -> Symbol

deletereservationhook!(
    sdn::MINDFul.AbstractSDNController,
    resourceview::MINDFul.ReservableResourceView,
    dagnodeid::Base.UUID;
    verbose
) -> Symbol

Implement this function to do custom actions per specific ReservableResourceView

edgeify(
    path::Vector{Int64}
) -> Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}}

emptyaggraphwithnewuuid(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Array{T<:MINDFul.NodeView, 1}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID},
    uuid::Base.UUID
) -> AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView

estimatecrossconnectionavailability(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestEmpiricalAvailabilityCompilation},
    ged::MINDFul.GlobalEdge;
    ...
) -> Distributions.DiscreteNonParametric{Float64, Float64, Vector{Float64}, Vector{Float64}}
estimatecrossconnectionavailability(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestEmpiricalAvailabilityCompilation},
    ged::MINDFul.GlobalEdge,
    ::Val;
    servicetime
) -> Distributions.DiscreteNonParametric{Float64, Float64, Vector{Float64}, Vector{Float64}}

estimatecrossconnectionavailability(
    ibnf::MINDFul.IBNFramework,
    ged::MINDFul.GlobalEdge;
    ...
) -> Distributions.DiscreteNonParametric{Float64, Float64, Vector{Float64}, Vector{Float64}}
estimatecrossconnectionavailability(
    ibnf::MINDFul.IBNFramework,
    ged::MINDFul.GlobalEdge,
    ::Val;
    servicetime
) -> Distributions.DiscreteNonParametric{Float64, Float64, Vector{Float64}, Vector{Float64}}

This function is called to estimate the second half availability constraint of the SplitGlobalNode

Final cross domain avaibility is the average empirical availability

estimatecrossconnectionavailability(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestAverageEmpiricalAvailabilityCompilation},
    ged::MINDFul.GlobalEdge;
    ...
) -> Float64
estimatecrossconnectionavailability(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestAverageEmpiricalAvailabilityCompilation},
    ged::MINDFul.GlobalEdge,
    ::Val;
    servicetime
) -> Float64

estimatecrossconnectionavailability(
    ibnf::MINDFul.IBNFramework,
    srcnode::MINDFul.GlobalNode,
    dstnode::MINDFul.GlobalNode;
    servicetime
)

estimateintentavailability(
    ibnf::MINDFul.IBNFramework,
    conintidagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent};
    ...
) -> Any
estimateintentavailability(
    ibnf::MINDFul.IBNFramework,
    conintidagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    output::Val;
    requested
) -> Any

Estimate the availability of an intent. It's used to reestimate the intent availability after the first split is done. The intent is usually an internal intent.

estimateintraconnectionavailability(
    ibnf::MINDFul.IBNFramework,
    srcnode::Int64,
    dstnode::Int64;
    ...
) -> Distributions.DiscreteNonParametric
estimateintraconnectionavailability(
    ibnf::MINDFul.IBNFramework,
    srcnode::Int64,
    dstnode::Int64,
    ::Val;
    servicetime
) -> Distributions.DiscreteNonParametric

This function is called to estimate the first half availability constraint of the SplitGlobalNode

estimateintraconnectionavailability(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestAverageEmpiricalAvailabilityCompilation},
    srclocalnode::Int64,
    dstlocalnode::Int64;
    ...
) -> Any
estimateintraconnectionavailability(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestAverageEmpiricalAvailabilityCompilation},
    srclocalnode::Int64,
    dstlocalnode::Int64,
    ::Val;
    servicetime
) -> Any

estimateintraconnectionavailability(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestEmpiricalAvailabilityCompilation},
    srclocalnode::Int64,
    dstlocalnode::Int64;
    ...
) -> Distributions.DiscreteNonParametric
estimateintraconnectionavailability(
    ibnf::MINDFul.IBNFramework{O, S, T, I, R} where {O<:MINDFul.AbstractOperationMode, S<:MINDFul.AbstractSDNController, T<:(AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView), I<:MINDFul.IBNFCommunication, R<:MINDFul.BestEmpiricalAvailabilityCompilation},
    srclocalnode::Int64,
    dstlocalnode::Int64,
    ::Val;
    servicetime
) -> Distributions.DiscreteNonParametric

findconsecutiveblocks(
    predicate::Function,
    vec::Vector
) -> Vector{Tuple{Int64, Int64}}

Return a Vector{Tuple{Int, Int}} with the consecutive blocks that satisfy function predicate. The first element of the tuple is the starting index and the second the last index of the block.

firstfit(
    boolvec::AbstractVector{Bool},
    lenghrequire::Int64
) -> Union{Nothing, Int64}

Finds first contiguous slot range of length lengthrequire that satisfies the boolvec. Return the starting index of the range or nothing if none available

generateRSAkeys(configdir::String)

Function to generate RSA keys (only used for testing). In real scenarios, private keys must be previously generated and public keys must be shared accordingly.

generateTLScertificate() -> Any

Function to generate a self-signed TLS certificate and corresponding private key.

generatelightpathoxcadddropbypassspectrumlli(
    path::Vector{Int64},
    spectrumslotsrange::UnitRange{Int64};
    sourceadddropport,
    opticalinitincomingnode,
    destadddropport
) -> Vector{MINDFul.OXCAddDropBypassSpectrumLLI}

Return a list of (@ref)[OXCAddDropBypassSpectrumLLI] that constitute a lightpath. According to the arguments a "starting lightpath", an "ending lightpath", or a "lightpath segment" can be created. The arguments are the following:

• sourceadddropport: nothing for a starting lightpath and an Integer denating the add/drop port otherwise
• opticalinitincomingnode : the (@ref)[LocalNode] denoting the incoming optical connection from the specified node for a starting lightpath. Set to nothing if not a starting lightpath
• destadddropport: nothing for an ending lightpath and an Integer denating the add/drop port otherwise

Note: not both sourceadddropport and opticalinitincomingnode can be nothing or have a values at the same time.

getafterlliidx(
    ibnf::MINDFul.IBNFramework,
    conintent::MINDFul.ConnectivityIntent,
    llis,
    oxclli::MINDFul.OXCAddDropBypassSpectrumLLI;
    verbose
) -> Any

Return all next logical low level intent indices from llis given that now signal is positioned in OXCAddDropBypassSpectrumLLI such that the conintent is satisfied. Return an empty vector if no logical next is found.

getafterlliidx(
    ibnf::MINDFul.IBNFramework,
    conintent::MINDFul.ConnectivityIntent,
    llis,
    rplli::MINDFul.RouterPortLLI;
    verbose
) -> Any

Return all next logical low level intent indices from llis given that now signal is positioned in RouterPortLLI such that the conintent is satisfied. Return an empty vector if no logical next is found.

getafterlliidx(
    ibnf::MINDFul.IBNFramework,
    conintent::MINDFul.ConnectivityIntent,
    llis,
    tmlli::MINDFul.TransmissionModuleLLI;
    verbose
) -> Any

Return all next logical low level intent indices from llis given that now signal is positioned in TransmissionModuleLLI such that the conintent is satisfied. Return an empty vector if no logical next is found.

getallflatpaths(
    cr::MINDFul.CachedResults
) -> Vector{Vector{Int64}}

getavailabilityrequirement(
    ac::MINDFul.AvailabilityConstraint
) -> Float64

getavailabilityrequirement(
    ac::MINDFul.MutableAvailabilityConstraint
) -> Float64

getavailabletransmissionmoduleviewindex(
    nodeview::MINDFul.NodeView
) -> Vector{Int64}

getbaseurl(
    remotehandler::MINDFul.AbstractIBNFHandler
) -> Any

Get the base URL of the HTTP server of a remote domain.

getcachedpaths(
    ibnf::MINDFul.IBNFramework,
    globaledge::MINDFul.GlobalEdge
) -> Any

getcachedresults(
    intcompalg::MINDFul.IntentCompilationAlgorithm
) -> Any

getcandidatepathsnum(
    intcompalg::MINDFul.IntentCompilationAlgorithm
) -> Any

getcompliancetarget(
    ac::MINDFul.AvailabilityConstraint
) -> Float64

getcompliancetarget(
    ac::MINDFul.MutableAvailabilityConstraint
) -> Float64

getcurrentlinkstate(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    edge::Graphs.SimpleGraphs.SimpleEdge;
    checkfirst,
    verbose
) -> Union{Nothing, Bool, Symbol}

Same as getcurrentlinkstate(ibnf::IBNFramework) but doesn't send a request to other domains.

getcurrentlinkstate(
    ibnf::MINDFul.IBNFramework,
    edge::Graphs.SimpleGraphs.SimpleEdge;
    checkfirst,
    verbose
) -> Any

getcurrentlinkstate(
    oxcview::MINDFul.OXCView,
    ed::Graphs.SimpleGraphs.SimpleEdge
) -> Bool

getdatetime(
    intcompalg::MINDFul.BasicAlgorithmMemory
) -> Dates.DateTime

getdatetime(
    intcompalg::MINDFul.IntentCompilationAlgorithm
) -> Any

getdatetime(rct::MINDFul.ReturnCodeTime) -> Dates.DateTime

getdatetime(rct::MINDFul.ReturnUUIDTime) -> Dates.DateTime

getdestinationnodeallocations(
    lpintent::MINDFul.LightpathIntent
) -> MINDFul.EndNodeAllocations

getdictlinkempiricalavailabilities(
    ibnf;
    checkfirst,
    verbose,
    endtime
) -> Dict

Return a dictionary with keys the edges and values the empirical availabilities.

getdictlinkupdowntimes(
    ibnf;
    checkfirst,
    verbose,
    endtime
) -> Dict

Return a dictionary with keys the edges and values the up and downtimes.

getempiricalavailability(
    ibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID
) -> Float64
getempiricalavailability(
    ibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID,
    endtime
) -> Float64

getempiricalavailability(
    ibnf::MINDFul.IBNFramework,
    path::Vector{Int64};
    checkfirst,
    verbose,
    endtime
) -> Any

Calculate empirical availability of a path

getempiricalavailability(
    ibnf::MINDFul.IBNFramework,
    ppath::Vector{Vector{Int64}};
    checkfirst,
    verbose,
    endtime
) -> Any

Calculate empirical availability of a protected path

getfirst(predicate::Function, ar::AbstractArray) -> Any

Returns the element is predicate is satisfied or nothing otherwise.

getfirstavailableoxcadddropport(nodeview::MINDFul.NodeView)

getfirstavailableoxcadddropport(oxcview::MINDFul.OXCView)

Return the first available oxc add/drop port and nothing if none found

getfirstavailablerouterportindex(nodeview::MINDFul.NodeView)

getfirstavailablerouterportindex(
    routerview::MINDFul.RouterView
)

Return the first available router port index and nothing if non available.

getfirstcompatibletransmoduleidxandmodeidx(
    transmissionmoduleviewpool::Vector{<:MINDFul.TransmissionModuleView},
    availtransmdlidxs::Vector{Int64},
    transmissionmodulecompat::MINDFul.TransmissionModuleCompatibility
) -> Union{Nothing, Tuple{Int64, Int64}}

Return a integer tuple (Int, Int) denoting the first available and compatible transmission module index and its transmission mode index. If non found return nothing.

getfirsthalfavailabilityconstraint(
    splitglobalnode::MINDFul.SplitGlobalNode
) -> Union{Nothing, MINDFul.AvailabilityConstraint}

getibnagweights(
    cr::MINDFul.CachedResults
) -> Matrix{Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}}

getibnfcomm(
    ibnf::MINDFul.IBNFramework
) -> MINDFul.IBNFCommunication

getibnfhandlergentoken(
    remotehandler::MINDFul.AbstractIBNFHandler
) -> Any

Get the generated token for authenticating a remote domain.

getibnfhandlerperm(
    remotehandler::MINDFul.AbstractIBNFHandler
) -> Any

Get the established permission of a remote domain.

getibnfhandlerport(
    remotehandler::MINDFul.AbstractIBNFHandler
) -> Int64

Get the port of the server of a remote domain.

getibnfhandlerrecvtoken(
    remotehandler::MINDFul.AbstractIBNFHandler
) -> Any

Get the received token for authenticating to a remote domain.

getibnfhandlerremoteids(s::MINDFul.IBNFramework) -> Any

getibnfhandlerrsapublickey(
    remotehandler::MINDFul.RemoteHTTPHandler
) -> String

Get the RSA public key of a remote domain.

getibnfhandlerrsasecret(
    remotehandler::MINDFul.RemoteHTTPHandler
) -> String

Get the RSA secret for authenticating a remote domain.

getibnfrsaprivatekey(ibnf::MINDFul.IBNFramework) -> Any

Get the RSA private key of a local domain.

getibnfserver(
    ibnf::MINDFul.IBNFramework
) -> Union{Nothing, HTTP.Servers.Server{HTTP.Servers.Listener{Nothing, Sockets.TCPServer}}, HTTP.Servers.Server{HTTP.Servers.Listener{MbedTLS.SSLConfig, Sockets.TCPServer}}}

Get the server of an IBNFramework.

getibnfwithid(
    ibnfs::Vector{<:MINDFul.IBNFramework},
    ibnfid::Base.UUID
) -> Union{Nothing, MINDFul.IBNFramework}

getidaginfo(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> MINDFul.IntentDAGInfo

getidagnextuuidcounter(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Base.UUID

getidagnode(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    dagnodeid::Base.UUID
) -> MINDFul.IntentDAGNode

getidagnodechildren(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Vector{MINDFul.IntentDAGNode}

getidagnodechildren(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnode::MINDFul.IntentDAGNode
) -> Vector{MINDFul.IntentDAGNode}

getidagnodedescendants(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID;
    exclusive,
    includeroot,
    parentsfirst
) -> Vector{MINDFul.IntentDAGNode}

Get all descendants of DAG dag starting from node idagnodeid Set exclusive=true to get nodes that have idagnodeid as the only ancestor Set parentsfirst=true to get the upper level children first and false to get the leafs first.

getidagnodedescendants_availabilityaware(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Vector{MINDFul.AbstractIntent}

Get all descendants of DAG dag starting from node idagnodeid Set exclusive=true to get nodes that have idagnodeid as the only ancestor Set parentsfirst=true to get the upper level children first and false to get the leafs first.

getidagnodeidx(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    dagnodeid::Base.UUID
) -> Union{Nothing, Int64}

Get the vertex index of the intent DAG node with id dagnodeid. Errors if UUID doesn't exist. It's slow: maybe keep a dict/table ?

getidagnodeidxdict(
    intentdaginfo::MINDFul.IntentDAGInfo
) -> Dict{Base.UUID, Int64}

getidagnodeidxsconnected(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID;
    includeroot
) -> Vector{Int64}

Get all connected nodes of DAG dag starting from node idagnodeid. Return as node indices of the graph.

getidagnodeidxsdescendants(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID;
    exclusive,
    includeroot
) -> Vector{Int64}

Get all descendants of DAG dag starting from node idagnodeid. Return as node indices of the graph. Set exclusive=true to get nodes that have idagnodeid as the only ancestor

getidagnodeleafs(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID;
    exclusive,
    chooseprotected,
    autoinstall
) -> Vector{MINDFul.IntentDAGNode}

Get the leafs of DAG dag starting from node idn. Set exclusive=true to get nodes that have idn as the only ancestor With chooseprotected::Int you can choose which protected path to select. Default is 1. With 0 you choose all. If an intent contains more than one ProtectedLightpathIntent there is no way to choose exactly. Pass autoinstall:Bool = true to ignore failed regions of the intent DAG and auto-choose protection path. It will choose the available path from 1 to n. chooseprotected must still be non-zero.

getidagnodeleafs2install(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID
) -> Vector{MINDFul.IntentDAGNode}

Return the leaf idagnodes to install. Code is very similar to getidagnodeleafs(::IntentDAG) but suited for exactly the isntallation scenario If installation is not possible return empty.

getidagnodellis(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID;
    exclusive
) -> Vector{MINDFul.IntentDAGNode}

Get all the Low Level Intents that are leafs of idagnodeid Set exclusive=true to get nodes that have idn as the only ancestor

getidagnodellis(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Vector{MINDFul.IntentDAGNode}

Get all the Low Level Intents that exist on the DAG

getidagnodeparents(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Vector{MINDFul.IntentDAGNode}

getidagnodeparents(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnode::MINDFul.IntentDAGNode
) -> Vector{MINDFul.IntentDAGNode}

getidagnodeparentsnum(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Int64

getidagnoderoots(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Vector{MINDFul.IntentDAGNode}

Get the roots of DAG dag starting from node idn.

getidagnoderootsnum(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Int64

Get the roots of DAG dag starting from node idn.

getidagnodes(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Vector{MINDFul.IntentDAGNode}

getinstalledlightpaths(
    intentdaginfo::MINDFul.IntentDAGInfo
) -> Dict{Base.UUID, MINDFul.LightpathRepresentation}

getintcompalg(
    s::MINDFul.IBNFramework
) -> MINDFul.IntentCompilationAlgorithm

getintentissuer(
    idagnode::MINDFul.IntentDAGNode
) -> MINDFul.IntentIssuer

getintervalavailability(
    ibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID
) -> Float64
getintervalavailability(
    ibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID,
    endtime
) -> Float64

getlightpathconnectivityintent(
    clpi::MINDFul.CrossLightpathIntent
) -> MINDFul.ConnectivityIntent

getlinkintentuuids(
    ibnf::MINDFul.IBNFramework,
    edge::Graphs.SimpleGraphs.SimpleEdge;
    offsettime
) -> Vector{Base.UUID}

getlinkstates(
    ibnf::MINDFul.IBNFramework,
    edge::Graphs.SimpleGraphs.SimpleEdge;
    checkfirst,
    verbose
) -> Any

getlinkstates(
    oxcview::MINDFul.OXCView,
    ed::Graphs.SimpleGraphs.SimpleEdge
) -> Vector{Tuple{Dates.DateTime, Bool}}

getlinkstates(
    oxcview::MINDFul.OXCView
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Tuple{Dates.DateTime, Bool}}}

getlinkupdowntimes(
    ibnf,
    edge;
    checkfirst,
    verbose,
    endtime
) -> MINDFul.UpDownTimes

Return the up and downtimes for the specific link

getlocalnodenum(ibnf::MINDFul.IBNFramework) -> Any

Return the number of local nodes, i.e. not border nodes.

getloginterupdowntimes(
    bam::MINDFul.BasicAlgorithmMemory
) -> Dict{MINDFul.GlobalEdge, Dict{Base.UUID, MINDFul.ConnectionData}}

getloginterupdowntimes(
    intentcomp::MINDFul.IntentCompilationAlgorithmWithMemory
) -> Dict{MINDFul.GlobalEdge, Dict{Base.UUID, MINDFul.ConnectionData}}

getlogintrapaths(
    bam::MINDFul.BasicAlgorithmMemory
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Dict{Vector{Vector{Int64}}, Int64}}

getlogintrapaths(
    intentcomp::MINDFul.IntentCompilationAlgorithmWithMemory
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Dict{Vector{Vector{Int64}}, Int64}}

getlogtupletstate(
    intentlogstatetuple::Tuple{Dates.DateTime, Enum{Int32}}
) -> Enum{Int32}

getlogtuplettime(
    intentlogstatetuple::Tuple{Dates.DateTime, Enum{Int32}}
) -> Dates.DateTime

getlowestratetransmissionmode(
    transmissionmoduleview::MINDFul.TransmissionModuleView,
    demandrate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}},
    demanddistance::Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}
) -> Union{Nothing, Int64}

Return the index with the lowest GBPS rate that can get deployed for the given demand rate and distance. If non is find return nothing.

getmaximumsplitlevel(
    lsc::MINDFul.LimitedSplitConstraint
) -> Int64

getname(s) -> Any

getnetworkoperatoridagnodes(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Vector{MINDFul.IntentDAGNode}

getnetworkoperatornremotenotinitidagnodes(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Vector{MINDFul.IntentDAGNode}

getnodeindex(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    globalnode::MINDFul.GlobalNode
) -> Union{Nothing, Int64}

Return the index given the global representation. Return nothing if not found

getoxclliedges(
    oxclli::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}}

getpath(lpintent::MINDFul.LightpathIntent) -> Vector{Int64}

getpath(
    lpr::MINDFul.LightpathRepresentation
) -> Vector{Vector{Int64}}

getpathdistance(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    path::Vector{Int64}
) -> Any

getpathdistance(ws::Matrix, path::Vector{Int64}) -> Any

getpathdistance2(ws::Matrix, path::Vector{Int64}) -> Any

getpathdistance3(ws::Matrix, path::Vector{Int64}) -> Any

getpathsforprotectionnum(
    intcompalg::MINDFul.IntentCompilationAlgorithm
) -> Any

getprdestinationnodeallocations(
    prlpintent::MINDFul.ProtectedLightpathIntent
) -> Vector{MINDFul.EndNodeAllocations}

getprpath(
    prlpintent::MINDFul.ProtectedLightpathIntent
) -> Vector{Vector{Int64}}

getprsourcenodeallocations(
    prlpintent::MINDFul.ProtectedLightpathIntent
) -> Vector{MINDFul.EndNodeAllocations}

getprspectrumslotsrange(
    prlpintent::MINDFul.ProtectedLightpathIntent
) -> Vector{UnitRange{Int64}}

getremoteconnectivityintent(
    clpi::MINDFul.CrossLightpathIntent
) -> MINDFul.ConnectivityIntent

getresidualbandwidth(
    ibnf::MINDFul.IBNFramework,
    lightpathuuid::Base.UUID,
    residualbandwidth::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}};
    onlyinstalled
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}

Return how much bandwidth is left unused in the lightpath

getresidualbandwidth(
    ibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID;
    onlyinstalled
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}

Return 0 GBPS if invalid intent

getreturncode(rct::MINDFul.ReturnCodeTime) -> Symbol

getrouterlli(
    ena::MINDFul.EndNodeAllocations
) -> MINDFul.RouterPortLLI

getrouterport(
    ibnf::MINDFul.IBNFramework,
    intent::MINDFul.RouterPortLLI
) -> MINDFul.RouterPort

Get the router port

getrouterport(s::MINDFul.RouterView, idx) -> Any

getrouterportrate(
    ibnf::MINDFul.IBNFramework,
    intent::MINDFul.RouterPortLLI
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}

Get the router port

getrouterportrate(
    tmc::MINDFul.TransmissionModuleCompatibility
) -> Union{Nothing, Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}}

getrouterports(
    s::MINDFul.RouterView
) -> Vector{MINDFul.RouterPort}

getsecondhalfavailabilityconstraint(
    splitglobalnode::MINDFul.SplitGlobalNode
) -> Union{Nothing, MINDFul.AvailabilityConstraint}

getservicetime(
    conintent::MINDFul.ConnectivityIntent
) -> Union{Nothing, Float64}

getsourcenodeallocations(
    lpintent::MINDFul.LightpathIntent
) -> MINDFul.EndNodeAllocations

getsplitlevel(lsc::MINDFul.LimitedSplitConstraint) -> Int64

getstaged(
    nodeview::MINDFul.NodeView
) -> Union{Nothing, Set{MINDFul.TransmissionModuleLLI}}

getstaged(
    oxcview::MINDFul.OXCView
) -> Set{MINDFul.OXCAddDropBypassSpectrumLLI}

getstaged(
    routerview::MINDFul.RouterView
) -> Set{MINDFul.RouterPortLLI}

getstartsoptically(
    lpr::MINDFul.LightpathRepresentation
) -> Bool

getterminatessoptically(
    lpr::MINDFul.LightpathRepresentation
) -> Bool

gettotalbandwidth(
    lpr::MINDFul.LightpathRepresentation
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}

gettrasmissionmodulelli(
    ena::MINDFul.EndNodeAllocations
) -> MINDFul.TransmissionModuleLLI

getupdowntimes(
    logstates::Array{Tuple{R, T}, 1}
) -> MINDFul.UpDownTimesNDatetime
getupdowntimes(
    logstates::Array{Tuple{R, T}, 1},
    endtime
) -> MINDFul.UpDownTimesNDatetime
getupdowntimes(
    logstates::Array{Tuple{R, T}, 1},
    endtime,
    distance
) -> MINDFul.UpDownTimesNDatetime

Get uptime and downtime periods from link/intent states. Return a tuple with the first element being the uptimes in Milliseconds and the second the downtimes in Milliseconds. If endtime is different that the one in list, pass it. Also return a simplified version of the log state vector

For links the state machine goes: true -> false -> true -> false -> ...

For intents the state machine goes: Installed -> Failed –> Installed –> Failed –> Compiled or Installed -> Failed –> Installed –> Failed –> Installed –> Compiled

getupdowntimes2!(
    updowntimesndatetime::MINDFul.UpDownTimesNDatetime,
    ls::Array{Tuple{R, T}, 1}
) -> MINDFul.UpDownTimesNDatetime
getupdowntimes2!(
    updowntimesndatetime::MINDFul.UpDownTimesNDatetime,
    ls::Array{Tuple{R, T}, 1},
    endtime
) -> MINDFul.UpDownTimesNDatetime

Incremeantaly update updowntimesndatetime given the new ls

getupdowntimes2(
    ls::Array{Tuple{R, T}, 1}
) -> Tuple{MINDFul.UpDownTimes, Vector{<:Tuple{Any, Any}}}
getupdowntimes2(
    ls::Array{Tuple{R, T}, 1},
    endtime
) -> Tuple{MINDFul.UpDownTimes, Vector{<:Tuple{Any, Any}}}

Get uptime and downtime periods from link states. Return a tuple with the first element being the uptimes in Milliseconds and the second the downtimes in Milliseconds. If endtime is different that the one in list, pass it.

getuuid(rct::MINDFul.ReturnUUIDTime) -> Base.UUID

getyenpathsdict(
    cr::MINDFul.CachedResults
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Vector{Int64}}}

getyenpathsdistsdict(
    cr::MINDFul.CachedResults
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}}}

groomifllichildexists!(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodegrandpa::MINDFul.IntentDAGNode,
    idagnodeparent::MINDFul.IntentDAGNode,
    lli::MINDFul.LowLevelIntent
) -> Bool

Groom (i.e. connect outgoing edge to the LLI) if it exists already as a child to idagnode Return true if it happens and false otherwise

handshake_init!(
    ibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteHTTPHandler,
    encryptedsecret::String
) -> Any

Exchange of the handshake information with the remote IBN framework. Both domains will generate a token to their peer that must be attached in the subsequent requests for authentication. Each domain has previously set a permission level for each of its neighbours. The available functions of the remote IBN framework will also be sent for information.

hasidagnodechildren(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Bool

hasidagnodechildren(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnode::MINDFul.IntentDAGNode
) -> Bool

hasidagnodeparents(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Bool

hasidagnodeparents(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnode::MINDFul.IntentDAGNode
) -> Bool

Highest values interval

hvi(x; alpha)

Take the mean of the elements inside the HVI

hvimean(x; alpha)

increaseidagcounter!(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Int64

insertreservation!(
    sdn::MINDFul.AbstractSDNController,
    resourceview::MINDFul.ReservableResourceView,
    dagnodeid::Base.UUID,
    reservationdescription;
    verbose
) -> Symbol

insertreservationhook!(
    sdn::MINDFul.AbstractSDNController,
    oxcview::MINDFul.OXCView,
    dagnodeid::Base.UUID,
    reservationdescription::MINDFul.OXCAddDropBypassSpectrumLLI;
    verbose
) -> Symbol

insertreservationhook!(
    sdn::MINDFul.AbstractSDNController,
    resourceview::MINDFul.ReservableResourceView,
    dagnodeid::Base.UUID,
    reservationdescription;
    verbose
) -> Symbol

Implement this function to do custom actions per specific ReservableResourceView

intradomaincompilationtemplate(
;
    prioritizepaths,
    prioritizegrooming,
    prioritizerouterport,
    prioritizetransmdlandmode,
    choosespectrum,
    chooseoxcadddropport,
    offsettime
) -> MINDFul.var"#386#387"{MINDFul.var"#388#389"{typeof(MINDFul.prioritizepaths_shortest), typeof(MINDFul.prioritizegrooming_default), typeof(MINDFul.prioritizerouterports_lowestrate), typeof(MINDFul.prioritizetransmdlmode_cheaplowrate), typeof(MINDFul.choosespectrum_firstfit), typeof(MINDFul.chooseoxcadddropport_first)}}

An intra domain compilation algorithm template. Return function to do the intra domain compilation with the signature

intradomainalgfun(
    ibnf::IBNFramework, 
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    cachedintentresult::Dict{ConnectivityIntent, Symbol}
    ; verbose::Bool = false,
    offsettime::DateTime
) -> MINDF.ReturnCodes

The returned algorithm can be customized as follows. The major selection process is made on the source.

Configuration Arguments

• prioritizepaths = prioritizepaths_shortest

It's the core pathfinding mechanism for the idagnode intent passed. Return the candidate paths with highest priority first as Vector{Vector{{Vector{Int}}}}. The first Vector are all the alternatives sorted per priority. The second Vector are the protected paths (if no protection is a single element vector). (Protection paths shouldnt end on border node) The third Vector is the path. Return empty collection if non available.

prioritizepaths(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
) -> Vector{Vector{Vector{LocalNode}}}

• prioritizegrooming = prioritizegrooming_default

It is invoked when the intent begins electrically (no OpticalInitiateConstraint). Pass the protectedpaths which are the options for deploying the intent irrespectively of grooming. Return a Vector of grooming possibilities: Vector{Vector{Union{UUID, Edge{Int}}}} Each element is a Vector of either an intent UUID or a new connectivity intent defined with Edge.

prioritizegrooming(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    protectedpaths::Vector{Vector{LocalNode}}
) -> Vector{Vector{Union{UUID, Edge{Int}}}}

• prioritizerouterport = prioritizerouterports_lowestrate

Return the candidate router ports with highest priority first The ports must be on node node and surpass the needed rate transmissionmoderate. Return empty collection if non available.

prioritizerouterport(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    node::LocalNode,
    transmissionmoderate::GBPSf
) -> Vector{Int}

• prioritizetransmdlandmode = prioritizetransmdlmode_cheaplowrate

Return the transmission module index and the transmission mode index of that module as a Vector{Tuple{Int, Int}} with the first being the transmission module index and the second the transmission mode. If this is calculated for the source node (default) pass path::Vector{LocalNode} and transmdlcompat::Nothing. If this is calculated for the destination node pass path::Nothing and transmdlcompat::TransmissionModuleCompatibility Return empty collection if non available.

prioritizetransmdlandmode(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    node::LocalNode,
    path::Union{Nothing, Vector{LocalNode}},
    routerportrate::GBPSf,
    transmdlcompat::Union{Nothing, TransmissionModuleCompatibility}=nothing
) -> Vector{Tuple{Int, Int}}

• choosespectrum = choosespectrum_firstfit

Return the first index of the spectrum slot range to be allocated. If none found, return nothing

choosespectrum(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    path::Vector{LocalNode},
    demandslotsneeded::Int
) -> Vector{Int}

• chooseoxcadddropport = chooseoxcadddropport_first

Return the index of the add/drop OXC port to allocate at node node If none found, return nothing

chooseoxcadddropport(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    node::LocalNode
) -> Vector{Int}

Interfaces

getcandidatepathsnum(
    intentcompilationalgorithm::IntentCompilationAlgorithm)
 -> Int

intradomaincompilationtemplate_destination!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    transmissionmodulecompat,
    opticalincomingnode::Int64,
    spectrumslotsrange::UnitRange{Int64},
    prioritizerouterport::Function,
    prioritizetransmdlmode::Function,
    chooseoxcadddropport::Function,
    mena::MINDFul.MutableEndNodeAllocations;
    verbose,
    offsettime
) -> Symbol

Takes care of the final node (destination). Return the returncode of the procedure. Also mutate lowlevelintentstoadd to add the low-level intents found.

The following functions must be passed in (entry point from intradomaincompilationtemplate)

Return the candidate router ports with highest priority first Return empty collection if non available.

prioritizerouterport(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    node::LocalNode
) -> Vector{Int}

Return the transmission module index and the transmission mode index of that module as a Vector{Tuple{Int, Int}} with the first being the transmission module index and the second the transmission mode. If this is calculated for the source node (default) pass path::Vector{LocalNode} and transmdlcompat::Nothing. If this is calculated for the destination node pass path::Nothing and transmdlcompat::TransmissionModuleCompatibility Return empty collection if non available.

prioritizetransmdlandmode(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    node::LocalNode,
    path::Union{Nothing, Vector{LocalNode}},
    routerportrate::GBPSf,
    transmdlcompat::Union{Nothing, TransmissionModuleCompatibility}=nothing
) -> Vector{Tuple{Int, Int}}

Return the index of the add/drop OXC port to allocate at node node If none found, return nothing

chooseoxcadddropport(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    node::LocalNode
) -> Vector{Int}

ipfiltering(tcp, neighbourips) -> Bool

Function to filter incoming TCP connections based on the IP address. It checks if the IP address of the incoming connection is either localhost or in the list of neighbour IPs. This is useful to prevent unauthorized access to the IBNFramework server.

is_low_level_intent(ci::MINDFul.ConnectivityIntent) -> Bool

isaddportallocation(
    oxcswitchentry::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Bool

Checks if this reservation reserves the add port, i.e., it's (0, x, y).

isdropportallocation(
    oxcswitchentry::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Bool

Checks if this reservation reserves the drop port, i.e., it's (x, y, 0).

isinternalorborderintent(
    ibnf::MINDFul.IBNFramework,
    connectivityintent::MINDFul.ConnectivityIntent;
    noremoteintent
) -> Bool

Return true if at least source or destination is internal. Pass ; noremoteintent=true to check whether there is an OpticalTerminateConstraint or an OpticalInitiateConstraint such that no RemoteIntent is needed.

isnodeviewinternal(nv::MINDFul.NodeView) -> Bool

isonlyoptical(ena::MINDFul.EndNodeAllocations) -> Bool

Return true if allocaitons on the node do not influence the electrical devices. This is equivalent to the OpticalInitiateConstraint and OpticalTerminateConstraint

isoxcllifail(
    ibnf::MINDFul.IBNFramework,
    oxclli::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Any

Return true if oxclli is involved with failed equipment

isreservationvalid(
    oxcswitchreservationentry::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Union{Bool, Symbol}
isreservationvalid(
    oxcswitchreservationentry::MINDFul.OXCAddDropBypassSpectrumLLI,
    verbose::Bool
) -> Union{Bool, Symbol}

issatisfied(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:Union{MINDFul.ConnectivityIntent, MINDFul.CrossLightpathIntent}};
    onlyinstalled,
    noextrallis,
    verbose,
    choosealternativeorder
) -> Any

Steps by step check if ibnf satisfies the intent For now works only with local view. The options are:

• onlyinstalled: only consideres installed intents
• noextrallis: all LLI must be used
• orderedllis: pass list to access ordered llis
• choosealternativeorder::Int. 0 to error in case multiple logical orders are available and the index of the alternative otherwise.

The function is not a definite assertion. The following cases are not covered:

• transmission module compatibility
• optical reach

issubpath(
    path::Vector{Int64},
    subpath::Vector{Int64}
) -> Bool

Return `true` if `subpath` is contained in `path`

isthesame(obj1, obj2) -> Any

Recursively compare all fields until a primitive element type is found

istransmissionmoduleandmodecompatible(
    transmissionmoduleview::MINDFul.TransmissionModuleView,
    transmissionmodesindex::Int64,
    transmissionmodulecompat::MINDFul.TransmissionModuleCompatibility
) -> Bool

Return true if the transmissionmoduleview and mode support the transmissionmodulecompat If onlymodecheck = true is passed then the disaggregation/protocol (aka name) will not be checked.

istransmissionmoduleandmodecompatible(
    transmissionmoduleview::MINDFul.TransmissionModuleView,
    transmissionmode::MINDFul.TransmissionMode,
    transmissionmodulecompat::MINDFul.TransmissionModuleCompatibility
) -> Bool

Return true if the transmissionmoduleview and mode support the transmissionmodulecompat If onlymodecheck = true is passed then the disaggregation/protocol (aka name) will not be checked.

istransmissionmoduleappropriate(
    transmissionmoduleview::MINDFul.TransmissionModuleView,
    demandrate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}},
    demanddistance::Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}
) -> Bool

Checks if the transmission module can get deployed for the given demand rate and distance

istransmissionmodulecompatible(
    transmissionmoduleview::MINDFul.TransmissionModuleView,
    transmissionmodulecompat::MINDFul.TransmissionModuleCompatibility
) -> Bool

Return true if transmissionmoduleview can support with its modes the transmissionmodulecompat

isvalidexternalintent(
    ibnf::MINDFul.IBNFramework,
    connectivityintent::MINDFul.ConnectivityIntent
) -> Bool

Return true if source node belongs to ibnf and destination node to another domain that is NOT a border node.

Return a Vector{Int} being the nodes that process electrically the signal

logicalordergetlightpaths(
    lo::Vector{<:MINDFul.LowLevelIntent}
) -> Vector

Return a Vector{Vector{Int}} being the lightpaths from the logical low level intent order

logicalordergetpath(
    lo::Vector{<:MINDFul.LowLevelIntent}
) -> Vector{Int64}

Return a Vector{Int} with the path given from the logical low level intent order

logicalorderissinglelightpath(
    lo::Vector{<:MINDFul.LowLevelIntent}
) -> Bool

Check that the LowLevelIntents are consisting a single LightPath implementation

This means that the order of the LLIs should be (RouterPortLLI) -> (TransmissionModuleLLI) -> OXCAddDropLLI -> (TranmsissionModuleLLI) -> (RouterPortLLI)

logintrapathsandinterintents!(
    ibnf::MINDFul.IBNFramework{A, B, C, D, R} where {A, B, C, D, R<:MINDFul.IntentCompilationAlgorithmWithMemory},
    idagnode::MINDFul.IntentDAGNode
)

main(; configfile)

main() function to initialize the MINDFul IBN framework. It expects the path of the configuration file in TOML format, in order to set up the IBNFrameworks for each domain and start the HTTP server that enables communication between domains. The path can be absolute or relative to the current working directory. The paths of the files referenced in the configuration file can be absolute or relative to the directory of the configuration file.

mycopy(whatever) -> Any

newoxcentry_adddropallocation(port::Int64)
newoxcentry_adddropallocation(
    port::Int64,
    spectrumslotsrange::UnitRange{Int64}
)

oxcllicontainsedge(
    oxclli::MINDFul.OXCAddDropBypassSpectrumLLI,
    edge::Graphs.SimpleGraphs.SimpleEdge
) -> Any

prioritizegrooming_default(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    protectedpaths::Vector{Vector{Int64}}
) -> Vector{Vector{Union{Base.UUID, Graphs.SimpleGraphs.SimpleEdge{Int64}}}}

Only grooms exactly upon the protectedpaths passed (which is the intended routing implementation without grooming) If there is no protection in protectedpaths (length(protectedpaths) <= 1) several combinations of already deployed intents are searched such that the end-to-end path from protectedpaths[1] is respected. Return a Vector{Vector{Union{UUID, Edge{Int}}}}. If there is protection (length(protectedpaths) > 1) exactly an intent with exactly the protectedpaths must be found. This method gives responsibility to the prioritizepaths method which cares for availability, so that grooming will not change the availability of the final path deployed.

Don't do grooming

prioritizepaths_shortest(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent}
) -> Vector{Vector{Vector{Int64}}}

prioritizepaths_stochasticavailability(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent}
) -> Vector{Vector{Vector{Int64}}}

Return a Vector{Vector{Int}} vector of vector of paths. Each element in the outer vector is a combination of paths to be used for protection. The first path is supposed to be the one deployed and all other are the protection. Constrained to return protection only up to 2 paths

prioritizerouterports_default(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64
) -> Vector{Int64}
prioritizerouterports_default(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64,
    transmissionmoderate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
) -> Vector{Int64}

prioritizerouterports_lowestrate(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64
) -> Vector{Int64}
prioritizerouterports_lowestrate(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64,
    transmissionmoderate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
) -> Vector{Int64}

Same as prioritizerouterports_lowestrate but with a sort! in the end

prioritizesplitbordernodes_shortestorshortestrandom(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent}
) -> Vector

Return a priority list of GlobalNode. If the target domain is known return the GlobalNode with the shortest distance. If the target domain is unknown return the border node with the shortest distance, excluding the (if) source domain.

prioritizesplitnodes_longestfirstshortestpath(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent}
) -> Vector{MINDFul.SplitGlobalNode}

Return the GlobalNode contained in the shortest path that is the longest to reach given the optical reach situation. The GlobalNode is used to break up the ConnectivityIntent into two. This is irrelevant to all availabilities decision. It just adapts the availability constraints based on the estimations.

prioritizetransmdlmode_cheaplowrate(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64,
    path::Union{Nothing, Vector{Int64}},
    routerportrate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
) -> Vector{Tuple{Int64, Int64}}
prioritizetransmdlmode_cheaplowrate(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64,
    path::Union{Nothing, Vector{Int64}},
    routerportrate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}},
    transmdlcompat::Union{Nothing, MINDFul.TransmissionModuleCompatibility}
) -> Vector{Tuple{Int64, Int64}}

Same as prioritizetransmdlmode_default with a sortperm! Return the index with the lowest GBPS rate that can get deployed for the given demand rate and distance. If non is find return nothing.

prioritizetransmdlmode_default(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64,
    path::Union{Nothing, Vector{Int64}},
    routerportrate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
) -> Vector{Tuple{Int64, Int64}}
prioritizetransmdlmode_default(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64,
    path::Union{Nothing, Vector{Int64}},
    routerportrate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}},
    transmdlcompat::Union{Nothing, MINDFul.TransmissionModuleCompatibility}
) -> Vector{Tuple{Int64, Int64}}

pushstatetoidagnode!(
    intentlogstate::Array{Tuple{Dates.DateTime, S}, 1} where S<:Enum{Int32},
    intentstate::MINDFul.IntentState.T;
    offsettime
) -> Array{Tuple{Dates.DateTime, S}, 1} where S<:Enum{Int32}

pushstatetoidagnode!(
    idagnode::MINDFul.IntentDAGNode,
    intentstate::MINDFul.IntentState.T;
    offsettime
) -> Vector{Tuple{Dates.DateTime, MINDFul.IntentState.T}}

readb64keys(finalkeyfile::String) -> String

Function to read a base64 encoded key from a PEM file.

removefrominstalledlightpaths!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode
) -> Bool

Remove from the installedlightpaths representation if exists Return true if done. Otherwise false

removeidagedge!(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    fromnode::Base.UUID,
    tonode::Base.UUID
) -> Bool

requestavailablecompilationalgorithms_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework
) -> Vector

Compilation algorithms are given as symbols because they might not be available programmatically to different IBN frameworks

requestavailablecompilationalgorithms_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteHTTPHandler
) -> Any

MA1069 implementation

requestcompileintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteHTTPHandler,
    idagnodeid::Base.UUID;
    ...
) -> Any
requestcompileintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteHTTPHandler,
    idagnodeid::Base.UUID,
    compilationalgorithmkey::Symbol;
    ...
) -> Any
requestcompileintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteHTTPHandler,
    idagnodeid::Base.UUID,
    compilationalgorithmkey::Symbol,
    compilationalgorithmargs::Tuple;
    verbose,
    offsettime
) -> Any

MA1069 implementation

requestcompileintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> Symbol

The initiator domain myibnf asks remoteibnf to compile the external remote intent idagnodeid with the specified compilation algorithm

requestcompileintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> Symbol

The initiator domain remoteibnf asks this domain myibnf to compile the internal remote intent idagnodeid with the specified compilation algorithm

requestcurrentlinkstate_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    ge::MINDFul.GlobalEdge
) -> Union{Nothing, Bool}

Request the link state of the border edge Need to check whether ge is indeed an edge shared with myibnf

requestcurrentlinkstate_term(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    ge::MINDFul.GlobalEdge
) -> Union{Nothing, Bool}

requestdelegateintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    intent::MINDFul.AbstractIntent,
    internalidagnodeid::Base.UUID;
    offsettime
) -> Base.UUID

Return the id of the new dag node if successful and nothing otherwise

requestdelegateintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteHTTPHandler,
    intent::MINDFul.AbstractIntent,
    internalidagnodeid::Base.UUID;
    offsettime
) -> Any

MA1069 implementation

Delegates an intent to another domain

Return the id of the new dag node if successful and nothing otherwise

requestglobalnodeelectricalpresence_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID;
    onlyinstalled
) -> Any

Request the path that is implementing intent intentuuid in the remote IBN framework as global node vector

requestglobalnodeelectricalpresence_term(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID;
    onlyinstalled
) -> Any

requestibnattributegraph_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework
) -> AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView

Request topology information

requestibnattributegraph_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework
) -> AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView

MA1069 implementation If far away, think about authorization and permissions. That's the reason why there are 2 arguments: The first argument should have the authorization.

requestibnfhandlers_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework
) -> Vector{H} where H<:MINDFul.AbstractIBNFHandler

Request the handlers of the handler

requestidag_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework
) -> AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}

Request intent dag information

MA1069 implementation

requestinstallintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime

requestinstallintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime

requestintentgloballightpaths_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID;
    onlyinstalled
) -> Vector

Request the path that is implementing intent intentuuid in the remote IBN framework as global node vector

requestintentgloballightpaths_term(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID;
    onlyinstalled
) -> Vector

requestintentglobalpath_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID;
    onlyinstalled
) -> Vector

Request the path that is implementing intent intentuuid in the remote IBN framework as global node vector

requestintentglobalpath_term(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID;
    onlyinstalled
) -> Vector

requestissatisfied_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    onlyinstalled,
    noextrallis,
    choosealternativeorder
) -> Any

Request to remoteibnf whether the idagnode is theoretically satisfied

requestissatisfied_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteHTTPHandler,
    idagnodeid::Base.UUID;
    onlyinstalled,
    noextrallis,
    choosealternativeorder
) -> Any

MA1069 implementation

Request to remoteibnf whether the idagnode is theoretically satisfied

requestlinkstates_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    ge::MINDFul.GlobalEdge
) -> Union{Nothing, Vector{Tuple{Dates.DateTime, Bool}}}

Request all the link states of the border edge Need to check whether ge is indeed an edge shared with myibnf

requestlogicallliorder_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID;
    onlyinstalled,
    verbose
) -> Union{Bool, Vector{MINDFul.LowLevelIntent}}

Request logical low level intent sequence

requestremoteintentstateupdate_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID,
    newstate::MINDFul.IntentState.T;
    offsettime
) -> Bool

Request the initiator remoteibnf to update the state of its mirrored remote intent

requestsetlinkstate_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    ge::MINDFul.GlobalEdge,
    operatingstate::Bool;
    offsettime
) -> Union{Nothing, MINDFul.ReturnCodeTime}

Request to set the state of the neighboring link

requestsetlinkstate_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    ge::MINDFul.GlobalEdge,
    operatingstate::Bool;
    offsettime
) -> Union{Nothing, MINDFul.ReturnCodeTime}

requestspectrumavailability_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    ge::MINDFul.GlobalEdge
) -> Union{Nothing, Vector{Bool}}

Request spectrum slot availabilities of the border edge Need to check whether ge is indeed an edge shared with myibnf

requestspectrumavailability_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteHTTPHandler,
    ge::MINDFul.GlobalEdge
) -> Any

MA1069 implementation

Request spectr /um slot availabilities of the border edge Need to check whether ge is indeed an edge shared with myibnf

requestuncompileintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> Symbol

requestuncompileintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> Symbol

requestuninstallintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    forceinstallable,
    offsettime
) -> MINDFul.ReturnCodeTime

requestuninstallintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    forceinstallable,
    offsettime
) -> MINDFul.ReturnCodeTime

reserve!(
    sdn::MINDFul.AbstractSDNController,
    resourceview::MINDFul.ReservableResourceView,
    lowlevelintent::MINDFul.LowLevelIntent,
    dagnodeid::Base.UUID;
    checkfirst,
    verbose
) -> Symbol

reserveunreserveleafintents!(
    ibnf::MINDFul.IBNFramework,
    idagnodeleaf::MINDFul.IntentDAGNode,
    doinstall::Bool;
    verbose,
    forceinstallable,
    offsettime
) -> Bool

to reserve pass doinstall=true, and to unreserve doinstall=false

rsaauthentication_encrypt(
    remoteibnfhandler::MINDFul.RemoteHTTPHandler,
    unencryptedsecret::String
) -> String

Function to perform RSA encryption on a secret using the public key of the remote IBNF.

rsaauthentication_init(
    ibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteHTTPHandler
) -> String

Exchange of encrypted secrets via RSA algorithm for mutual authentication with the remote domain. The initiator domain will generate a secret, encrypt it with the public key of the remote domain, and send it. The remote domain will decrypt the secret with its private key, and return the decrypted secret concatenated with a new secret (the concatenation is encrypted with the initiator's public key). The initiator domain will then decrypt with its private key, check the initial secret and return the new secret encrypted in the handshake.

sendrequest(
    ibnf::MINDFul.IBNFramework,
    remotehandler::MINDFul.RemoteHTTPHandler,
    endpoint::String,
    data::Dict;
    offsettime
) -> Response

Function used to send a request to a remote IBNFramework handler. It also handles the initial authentication and sends the requests with the provided data.

setadddropport!(
    ena::MINDFul.MutableEndNodeAllocations,
    intval::Union{Nothing, Int64}
) -> Union{Nothing, Int64}

setavailabilityrequirement!(
    mav::MINDFul.MutableAvailabilityConstraint,
    newval::Float64
) -> Float64

setcompliancetarget!(
    mav::MINDFul.MutableAvailabilityConstraint,
    newval::Float64
) -> Float64

setdatetime!(
    intcompalg::MINDFul.BasicAlgorithmMemory,
    currentdatetime::Dates.DateTime
) -> Dates.DateTime

setdatetime!(
    intcompalg::MINDFul.IntentCompilationAlgorithm,
    currentdatetime::Dates.DateTime
) -> Dates.DateTime

setibnfhandlergentoken!(
    remotehandler::MINDFul.AbstractIBNFHandler,
    generatedtoken::String
) -> String

Set the generated token for authenticating a remote domain.

setibnfhandlerrecvtoken!(
    remotehandler::MINDFul.AbstractIBNFHandler,
    receivedtoken::String
) -> String

Set the received token for authenticating to a remote domain.

setibnfhandlerrsasecret!(
    remotehandler::MINDFul.RemoteHTTPHandler,
    secret::String
) -> String

Set the RSA secret for authenticating a remote domain.

setibnfserver!(
    ibnf::MINDFul.IBNFramework,
    server::Union{HTTP.Servers.Server{HTTP.Servers.Listener{Nothing, Sockets.TCPServer}}, HTTP.Servers.Server{HTTP.Servers.Listener{MbedTLS.SSLConfig, Sockets.TCPServer}}}
) -> Union{HTTP.Servers.Server{HTTP.Servers.Listener{Nothing, Sockets.TCPServer}}, HTTP.Servers.Server{HTTP.Servers.Listener{MbedTLS.SSLConfig, Sockets.TCPServer}}}

Set the running server of an IBNFramework.

setlinkstate!(
    ibnf::MINDFul.IBNFramework,
    edge::Graphs.SimpleGraphs.SimpleEdge,
    operatingstate::Bool;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime

Set the link state on both OXCView ends of edge

setlinkstate!(
    ibnf::MINDFul.IBNFramework,
    oxcview::MINDFul.OXCView,
    edge::Graphs.SimpleGraphs.SimpleEdge,
    operatingstate::Bool;
    offsettime
) -> MINDFul.ReturnCodeTime

Set the operating state of the edge in oxcview and trigger the state update of the relevant low level intents.

setlocalnode!(
    ena::MINDFul.MutableEndNodeAllocations,
    intval::Union{Nothing, Int64}
) -> Union{Nothing, Int64}

setlocalnode_input!(
    ena::MINDFul.MutableEndNodeAllocations,
    intval::Union{Nothing, Int64}
) -> Union{Nothing, Int64}

setlocalnode_output!(
    ena::MINDFul.MutableEndNodeAllocations,
    intval::Union{Nothing, Int64}
)

setoxcviewlinkavailabilities!(
    oxcview::MINDFul.OXCView,
    oxcadddropbypassspectrumlli::MINDFul.OXCAddDropBypassSpectrumLLI,
    setflag::Bool;
    verbose
) -> Symbol

Set the link spectrum availabilities of the oxcview based on the OXC low level intent to setflags

setrouterportindex!(
    ena::MINDFul.MutableEndNodeAllocations,
    intval::Union{Nothing, Int64}
) -> Union{Nothing, Int64}

settransmissionmodesindex!(
    ena::MINDFul.MutableEndNodeAllocations,
    intval::Union{Nothing, Int64}
) -> Union{Nothing, Int64}

settransmissionmoduleviewpoolindex!(
    ena::MINDFul.MutableEndNodeAllocations,
    intval::Union{Nothing, Int64}
) -> Union{Nothing, Int64}

splitandcompilecrossdomainconnectivityintent(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intradomainalgfun::Function,
    splitbordernode::MINDFul.SplitGlobalNode,
    cachedintentresult::Dict{MINDFul.ConnectivityIntent, Symbol};
    verbose,
    offsettime
) -> Symbol

splitandcompileintradomainconnecivityintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intradomainalgfun::Function,
    splitglobalnode::MINDFul.SplitGlobalNode,
    cachedintentresult::Dict{MINDFul.ConnectivityIntent, Symbol};
    verbose,
    prioritizesplitnodes,
    prioritizesplitbordernodes,
    maximumsplitlevel,
    offsettime
)

Splits connectivity intent on splitglobalnode with O-E-O conversion

stage!(
    resourceview::MINDFul.ReservableResourceView,
    lli::MINDFul.LowLevelIntent;
    verbose
) -> Symbol

stageaddidagnode!(
    ibnf::MINDFul.IBNFramework,
    lli::MINDFul.LowLevelIntent;
    parentid,
    intentissuer,
    offsettime
) -> Union{Nothing, Symbol}

Stage lli as compiled in the equipment and add LLI in the intent DAG. Staged LLIs are not reserved but used to know that they will be in the future.

stageunstageleafintent!(
    ibnf::MINDFul.IBNFramework,
    lli::MINDFul.LowLevelIntent,
    dostage::Bool;
    about2install
) -> Union{Nothing, Symbol}

dostage true for stage, false for unstage about2install = true only when dostage=false for unstaging when groing to installed state. This is only used to not deallocate the spectrum.

startibnserver!(
    ibnfsdict::Dict{Int64, MINDFul.IBNFramework},
    encryption::Bool,
    neighbourips::Vector{String},
    port::Int64;
    verbose
) -> HTTP.Servers.Server

Function to start the HTTP server of an IBNFramework.

unreserve!(
    sdn::MINDFul.AbstractSDNController,
    resourceview::MINDFul.ReservableResourceView,
    dagnodeid::Base.UUID;
    verbose
) -> Symbol

unstage!(
    resourceview::MINDFul.ReservableResourceView,
    lli::MINDFul.LowLevelIntent;
    verbose,
    about2install
) -> Symbol

updateestimations!(
    ibnf::MINDFul.IBNFramework,
    currenttime::Dates.DateTime
)

If estimating is a slow procedure, we have some batched simulations. For that this function will be updated. This must be called from the simulation code and is not directly called from MINDFul

updateidagnodestates!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode;
    ...
) -> Bool
updateidagnodestates!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode,
    makestate::Union{Nothing, MINDFul.IntentState.T};
    offsettime
) -> Bool

Return value is true if state is changed.

• ibnf
• idagnode
• makestate needed if a certain state is wished, e.g. upon failure or repair

updatelogintentcomp!(
    ibnf::MINDFul.IBNFramework{A, B, C, D, R} where {A, B, C, D, R<:MINDFul.IntentCompilationAlgorithmWithMemory};
    offsettime
)

updatelogintentcomp!(
    ibnf::MINDFul.IBNFramework{A, B, C, D, E};
    offsettime
)

This macro is used to calculate the current (simulated) time as offsettime + (now() - entrytime)

This macro is used to pass the (simulated) timing information. It basically passes (; offsettime)

This strategy calls now() every time before passing the arguments. If that proves to slow down the implementation consider to pass offsettime, entrytime around and calcualte @logtime once in the end. Another caveat is that the communication overhead between domains is not measured. An offsetime=nothing logs the time of the current system.

This macro is used to receive the (simulated) timing information. This macro does two things:

• puts the offsettime::DateTime=now() in the input keyword parameters
• puts entrytime = now() as the first command to happen in the function

Use @logtime to calculate the current time inside the function. Use @passtime to pass the timing information to another function.

Return a return false if the expression ex evaluates to false. If verbose=true print the statement and the location. If the expression passed is true do nothing.

Return a return ReturnCodes.Fail if the expression ex evaluates to false. If verbose=true print the statement and the location. If the expression passed is true do nothing.

Return a return ReturnCodeTime(ReturnCodes.Fail, @logtime) if the expression ex evaluates to false. That need to happen inside a @recvtime function If verbose=true print the statement and the location. If the expression passed is true do nothing.