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
) -> Union{Nothing, Symbol, Vector{Bool}}

Get the spectrum availability slots vector for edge

getglobalnode(s) -> Any

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

getibnag(s) -> Any

Get the IBNAttributeGraph

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

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
) -> Any

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
) -> Base.UUID

kk Add a new user intent to the IBN framework and return the id.

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

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

compileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.LightpathIntent},
    algorithm::MINDFul.IntentCompilationAlgorithm;
    verbose,
    offsettime
)

compileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.RemoteIntent},
    algorithm::MINDFul.IntentCompilationAlgorithm;
    verbose,
    offsettime
)

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
) -> Symbol

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
) -> Symbol

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

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

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 keyword for KShorestPathFirstFitCompilation

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

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

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

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.

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), H<:MINDFul.AbstractIBNFHandler} <: 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

• ibnfhandlers::Vector{H} where H<:MINDFul.AbstractIBNFHandler: Other IBN Frameworks handles

• sdncontroller::MINDFul.AbstractSDNController: SDN controller handle

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

The most default construct with abstract type of IBN handlers

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}
) -> MINDFul.IBNFramework{MINDFul.DefaultOperationMode, MINDFul.SDNdummy}

Constructor that specify IBNFHandlers to make it potentially type stable

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

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)

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

struct KShorestPathFirstFitCompilation <: MINDFul.IntentCompilationAlgorithm

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

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{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

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 RemoteIBNFHandler <: MINDFul.AbstractIBNFHandler

Fabian Gobantes implementation. Should consist of basic information all handlers should have (e.g. ibnfid). And a parametric type specific to the protocol used.

    struct HandlerProperties
        ibnfid::UUID
        # ...
    end

    struct IBNFHTTP2Comm <: AbstractIBNFComm
        # example
    end

    struct IBNFSameProcess{T<:IBNFramework} <: AbstractIBNFComm
        # this can  be the new dummy and substitute the current dummy implementation
        ibng::T
    end

    struct RemoteIBNFHandler{T<:AbstractIBNFComm} <: AbstractIBNFHandler
        handlerproperties::HandlerProperties
        ibnfcomm::T
    end

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 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 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

• 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{<:Union{MINDFul.LightpathIntent, MINDFul.CrossLightpathIntent}}
) -> Bool

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

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

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

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

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

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

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

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

compileintenttemplate!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm;
    verbose,
    intradomainalgfun,
    externaldomainalgkeyword,
    prioritizegrooming,
    prioritizesplitnodes,
    prioritizesplitbordernodes,
    offsettime
)

A template compilation function that can be extended

Pass in the intent compilation algorithm intentcompilationalgorithm

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

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

• prioritizesplitnodes is called when optical reach is not enough to have a lightpath end-to-end to serve the intent and a path to split was already selected.

The node selected will break the intent into two pieces with the node standing in between. This function should return a vector of GlobalNodes with decreasing priority of which node should be chosen.

prioritizesplitnodes(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode,
    intentcompilationalgorithm::IntentCompilationAlgorithm,
) -> Vector{GlobalNode}

• 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 GlobalNodes with decreasing priority of which node should be chosen.

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

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.

construct_BoolLogState(

) -> Vector{Tuple{Dates.DateTime, Bool}}
construct_BoolLogState(
    initialstate
) -> Vector{T} where T<:Tuple{Dates.DateTime, 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.

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

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

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

displayavailablecompilationalgorithmsinfo(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler
)

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

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

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.

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

getcandidatepathsnum(
    kspffcomp::MINDFul.KShorestPathFirstFitCompilation
) -> Int64

getcompilationalgorithmkeyword(
    _::Type{MINDFul.KShorestPathFirstFitCompilation}
) -> Symbol

Give back the symbol mapped to the algorithm

getcompilationalgorithmkeyword(
    c::MINDFul.IntentCompilationAlgorithm
) -> Symbol

Give back the symbol mapped to the algorithm

getcompilationalgorithmtype(
    s::Val{:kspff}
) -> Type{MINDFul.KShorestPathFirstFitCompilation}

Give back the algorithm mapped to the symbol

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
) -> Union{Nothing, Bool, Symbol}

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

getdefaultcompilationalgorithm(
    ibnff::MINDFul.IBNFramework
) -> Symbol

Can overload for different Operation Modes.

getdefaultcompilationalgorithmargs(
    s::Val{:kspff}
) -> Tuple{Int64}

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

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.

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.

getidagnodeidx(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    dagnodeid::Base.UUID
) -> 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 ?

getidagnodeidxsconnected(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> 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
) -> 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

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}

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.

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}

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

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

getlinkstates(
    ibnf::MINDFul.IBNFramework,
    edge::Graphs.SimpleGraphs.SimpleEdge;
    checkfirst,
    verbose
) -> Union{Nothing, Symbol, Vector{Tuple{Dates.DateTime, Bool}}}

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}}}

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

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

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.

getname(s) -> Any

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

Request topology information

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

getnumberofparameters(
    _::MINDFul.IntentCompilationAlgorithm
) -> Int64

getnumberofparameters(
    _::Type{T<:MINDFul.IntentCompilationAlgorithm}
) -> Int64

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

getpath(
    lpr::MINDFul.LightpathRepresentation
) -> 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

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

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

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

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

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

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

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"#224#234"{MINDFul.var"#224#225#235"{typeof(MINDFul.prioritizepaths_shortest), typeof(MINDFul.prioritizegrooming_default), typeof(MINDFul.prioritizerouterports_lowestrate), typeof(MINDFul.prioritizetransmdlmode_cheaplowrate), typeof(MINDFul.choosespectrum_firstfit), typeof(MINDFul.chooseoxcadddropport_first)}}

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

intradomainalgfun(
    ibnf::IBNFramework, 
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    intentcompilationalgorithm::IntentCompilationAlgorithm
) -> Symbol

The returned algorithm can be customized as follows.

The major selection process is made on the source.

Interfaces needed:

getcandidatepathsnum(
    intentcompilationalgorithm::IntentCompilationAlgorithm)
 -> Int

Return the candidate paths with highest priority first as Vector{Vector{Int}}}. Return empty collection if non available.

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

Return a Vector of grooming possibilities. 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}, 
    intentcompilationalgorithm::IntentCompilationAlgorithm)

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

prioritizerouterport(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    intentcompilationalgorithm::IntentCompilationAlgorithm,
    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},
    intentcompilationalgorithm::IntentCompilationAlgorithm,
    node::LocalNode,
    path::Union{Nothing, Vector{LocalNode}},
    transmdlcompat::Union{Nothing, TransmissionModuleCompatibility}=nothing
) -> Vector{Tuple{Int, Int}}

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

choosespectrum(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    intentcompilationalgorithm::IntentCompilationAlgorithm,
    path::Vector{LocalNode},
    demandslotsneeded::Int
) -> Vector{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},
    intentcompilationalgorithm::IntentCompilationAlgorithm,
    node::LocalNode
) -> Vector{Int}

intradomaincompilationtemplate_destination!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm,
    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},
    intentcompilationalgorithm::IntentCompilationAlgorithm,
    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},
    intentcompilationalgorithm::IntentCompilationAlgorithm,
    node::LocalNode,
    path::Union{Nothing, Vector{LocalNode}},
    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},
    intentcompilationalgorithm::IntentCompilationAlgorithm,
    node::LocalNode
) -> Vector{Int}

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

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
) -> Union{Bool, Symbol}

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

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`

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

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)

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},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm
) -> Vector{Vector{Union{Base.UUID, Graphs.SimpleGraphs.SimpleEdge{Int64}}}}

Return a Vector of grooming possibilities.
Suggest grooming only if remains on the same path.
Suggest grooming only if one extra router port pair is used.

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`.

Sorting of the grooming possibilities is done just by minimizing lightpaths used

Don't do grooming

prioritizepaths_shortest(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm
) -> Vector{T} where T<:(Vector{U} where U<:Integer)

prioritizerouterports_lowestrate(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm,
    node::Int64
) -> Vector{Int64}

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

Return a single choice of GlobalNode and not several candidates. 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},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm
) -> Vector{MINDFul.GlobalNode}

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. Not several candidates are returned but only a single choice.

prioritizetransmdlmode_cheaplowrate(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm,
    node::Int64,
    path::Union{Nothing, Vector{Int64}}
) -> Vector{Tuple{Int64, Int64}}
prioritizetransmdlmode_cheaplowrate(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm,
    node::Int64,
    path::Union{Nothing, Vector{Int64}},
    transmdlcompat::Union{Nothing, MINDFul.TransmissionModuleCompatibility}
) -> Vector{Tuple{Int64, 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.

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}}

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(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework
) -> Vector{Symbol}

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

requestavailablecompilationalgorithms(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteIBNFHandler
)

MA1069 implementation

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

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

requestcompileintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteIBNFHandler;
    ...
)
requestcompileintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteIBNFHandler,
    compilationalgorithm::Symbol;
    ...
)
requestcompileintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteIBNFHandler,
    compilationalgorithm::Symbol,
    compilationalgorithmkey::Tuple;
    verbose
)

MA1069 implementation

requestcompileintent_term!(
    remoteibnfhandler::MINDFul.RemoteIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID
)
requestcompileintent_term!(
    remoteibnfhandler::MINDFul.RemoteIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID,
    compilationalgorithmkey::Symbol
)
requestcompileintent_term!(
    remoteibnfhandler::MINDFul.RemoteIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID,
    compilationalgorithmkey::Symbol,
    compilationalgorithmargs::Tuple
)

MA1069 implementation

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

requestcompileintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    ...
)
requestcompileintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID,
    compilationalgorithmkey::Symbol;
    ...
)
requestcompileintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID,
    compilationalgorithmkey::Symbol,
    compilationalgorithmargs::Tuple;
    verbose,
    offsettime
)

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!(
    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!(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteIBNFHandler,
    intent::MINDFul.AbstractIntent,
    internalidagnodeid::Base.UUID
)

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(
    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(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteIBNFHandler
)

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
) -> Symbol

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

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(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    onlyinstalled,
    noextrallis
) -> Union{Bool, Symbol}

Request to remoteibnf whether the idagnode is theoretically satisfied

requestissatisfied(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.RemoteIBNFHandler,
    idagnode::MINDFul.IntentDAGNode;
    onlyinstalled,
    noextrallis
)

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!(
    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, Symbol}

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, Symbol}

requestspectrumavailability(
    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(
    myibnf::MINDFul.IBNFramework,
    remoteibnfhandler::MINDFul.RemoteIBNFHandler,
    ge::MINDFul.GlobalEdge
)

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,
    offsettime
) -> Symbol

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

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,
    offsettime
) -> Bool

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

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

setlinkstate!(
    ibnf::MINDFul.IBNFramework,
    edge::Graphs.SimpleGraphs.SimpleEdge,
    operatingstate::Bool;
    offsettime
) -> Union{Nothing, Symbol}

Set the link state on both OXCView ends of edge

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

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},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm,
    intradomainalgfun::Function,
    externaldomainalgkeyword::Symbol,
    mediatorbordernode::MINDFul.GlobalNode;
    verbose,
    offsettime
) -> Symbol

splitandcompileintradomainconnecivityintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm,
    intradomainalgfun::Function,
    splitglobalnode::MINDFul.GlobalNode;
    verbose,
    offsettime
) -> Any

Splits connectivity intent on splitglobalnode

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

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

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
) -> Union{Nothing, Symbol, Set}

dostage true for stage, false for unstage

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

unstage!(
    resourceview::MINDFul.ReservableResourceView,
    lli::MINDFul.LowLevelIntent
) -> Set

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.

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. TODO: have also a helper message be printed