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

compileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    beacomp::MINDFul.BestEmpiricalAvailabilityCompilation;
    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
) -> Symbol

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

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

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

The keyword for KShorestPathFirstFitCompilation

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 BestEmpiricalAvailabilityCompilation <: MINDFul.IntentCompilationAlgorithm

• 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

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

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.

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

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

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;
    ...
) -> 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,
    ibnfsdict::Dict{Int64, MINDFul.IBNFramework};
    verbose
) -> MINDFul.IBNFramework{MINDFul.DefaultOperationMode}

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

Stores a single log element for the intent state and time

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

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

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

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

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.

Choose exactly the grooming for protectedpaths If many protectedpaths are passed, there can only be matched with a single protection lightpath intent that has the same paths If just one path is passed, it can be broken down to several lightpaths but that must have the same nodes.

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}

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

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

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

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.

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

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

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

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

getcandidatepathsnum(
    beacomp::MINDFul.BestEmpiricalAvailabilityCompilation
) -> Int64

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

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

Give back the symbol mapped to the algorithm

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{:bestempiricalavailability}
) -> Type{MINDFul.BestEmpiricalAvailabilityCompilation}

Give back the algorithm mapped to the symbol

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

Give back the algorithm mapped to the symbol

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

getcurrentdatetime(
    beacomp::MINDFul.BestEmpiricalAvailabilityCompilation
) -> Dates.DateTime

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

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

Can overload for different Operation Modes.

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

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

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.

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.

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.

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.

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

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

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.

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

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

getpathsforprotectionnum(
    beacomp::MINDFul.BestEmpiricalAvailabilityCompilation
) -> Int64

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

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}

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

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.

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

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"#302#310"{MINDFul.var"#302#303#311"{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. TODO docts protection: Protection paths... shouldnt end on border node !

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}},
    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},
    intentcompilationalgorithm::IntentCompilationAlgorithm,
    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

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)

main()

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},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm;
    candidatepaths
) -> 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

prioritizegrooming_exactly(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm;
    candidatepaths
) -> Vector{Vector{Union{Base.UUID, Graphs.SimpleGraphs.SimpleEdge{Int64}}}}

Return suggestion that match exactly the candidatepaths, such that availability is not changed. All the protection paths need to be matched exactly.

Don't do grooming

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

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.

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

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

prioritizetransmdlmode_cheaplowrate(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm,
    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},
    intentcompilationalgorithm::MINDFul.IntentCompilationAlgorithm,
    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}}

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

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

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;
    ...
) -> Any
requestcompileintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID,
    compilationalgorithmkey::Symbol;
    ...
) -> Any
requestcompileintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID,
    compilationalgorithmkey::Symbol,
    compilationalgorithmargs::Tuple;
    verbose,
    offsettime
) -> Any

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;
    ...
) -> Any
requestcompileintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID,
    compilationalgorithmkey::Symbol;
    ...
) -> Any
requestcompileintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID,
    compilationalgorithmkey::Symbol,
    compilationalgorithmargs::Tuple;
    verbose,
    offsettime
) -> Any

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
) -> 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_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, 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_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,
    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

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}

setcurrentdatetime!(
    beacomp::MINDFul.BestEmpiricalAvailabilityCompilation,
    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;
    offsettime
) -> 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 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

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