GitHub

Public getters interface

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

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

source
MINDFul.getborderglobaledges — Method
getborderglobaledges(ibnf::MINDFul.IBNFramework) -> Vector

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

source
MINDFul.getconstraints — Method
getconstraints(
    conintent::MINDFul.ConnectivityIntent
) -> Vector{T} where T<:MINDFul.AbstractIntentConstraint
source
MINDFul.getcurrentstate — Method
getcurrentstate(
    intentlogstate::Array{Tuple{Dates.DateTime, S}, 1} where S<:Enum{Int32}
) -> Enum{Int32}
source
MINDFul.getdistance — Method
getdistance(
    s
) -> Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}
source
MINDFul.getdistance — Method
getdistance(
    s::MINDFul.EdgeView
) -> Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}
source
MINDFul.getedgeview — Method
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
source
MINDFul.getedgeviews — Method
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
source
MINDFul.getfiberspectrumavailabilities — Method
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}}
source
MINDFul.getfiberspectrumavailabilities — Method
getfiberspectrumavailabilities(
    ibnf::MINDFul.IBNFramework,
    edge::Graphs.SimpleGraphs.SimpleEdge{Int64};
    checkfirst,
    verbose
) -> Any

Get the spectrum availability slots vector for edge

source
MINDFul.getglobalnode — Method
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

source
MINDFul.getibnfhandler — Method
getibnfhandler(
    s::MINDFul.IBNFramework
) -> MINDFul.IBNFramework

Get the handler of the given IBNFramework.

source
MINDFul.getibnfid — Method
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
source
MINDFul.getidag — Method
getidag(
    s::MINDFul.IBNFramework
) -> AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}

Get the IntentDAG

source
MINDFul.getidagcounter — Method
getidagcounter(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Int64
source
MINDFul.getidagnodestate — Method
getidagnodestate(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    dagnodeid::Base.UUID
) -> MINDFul.IntentState.T
source
MINDFul.getintranodeviews — Method
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
source
MINDFul.getlocalnode — Method
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

source
MINDFul.getlogstate — Method
getlogstate(
    idagnode::MINDFul.IntentDAGNode
) -> Vector{Tuple{Dates.DateTime, MINDFul.IntentState.T}}
source
MINDFul.getnodeview — Method
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
source
MINDFul.getnodeview — Method
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
source
MINDFul.getnodeviews — Method
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
source
MINDFul.getopticalinitiateconstraint — Method
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.

source
MINDFul.getopticalreach — Method
getopticalreach(
    tm::MINDFul.TransmissionMode
) -> Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}
source
MINDFul.getpathspectrumavailabilities — Method
getpathspectrumavailabilities(
    ibnf::MINDFul.IBNFramework,
    localnodespath::Vector{Int64};
    checkfirst
) -> Vector{Bool}

Get spectrum availabilities along a path of nodes as a BitVector

source
MINDFul.getrate — Method
getrate(
    conintent::MINDFul.ConnectivityIntent
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
source
MINDFul.getrate — Method
getrate(
    s::MINDFul.RouterPort
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
source
MINDFul.getrate — Method
getrate(
    tm::MINDFul.TransmissionMode
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
source
MINDFul.getrate — Method
getrate(
    tmc::MINDFul.TransmissionModuleCompatibility
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
source
MINDFul.getreservations — Method
getreservations(
    nodeview::MINDFul.NodeView
) -> Union{Nothing, Dict{Base.UUID, MINDFul.TransmissionModuleLLI}}
source
MINDFul.getreservedtransmissionmode — Method
getreservedtransmissionmode(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{MINDFul.TransmissionModuleLLI};
    verbose
) -> Union{MINDFul.TransmissionMode, Symbol}

Get the reserved transmission mode

source
MINDFul.gettransmissionmode — Method
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
source
MINDFul.gettransmissionmode — Method
gettransmissionmode(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{MINDFul.TransmissionModuleLLI}
) -> MINDFul.TransmissionMode

Get the transmission mode

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

Get the transmission mode

source
MINDFul.gettransmissionmodule — Method
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
source
MINDFul.gettransmissionmodule — Method
gettransmissionmodule(
    ibnf::MINDFul.IBNFramework,
    intent::MINDFul.TransmissionModuleLLI
) -> MINDFul.TransmissionModuleView

Get the transmission mode

source
MINDFul.getweights — Method
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
source

Other public interface

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

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

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

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

source
MINDFul.compileintent! — Method
compileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.LightpathIntent};
    verbose,
    offsettime
) -> Symbol
source
MINDFul.compileintent! — Method
compileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ProtectedLightpathIntent};
    verbose,
    offsettime
) -> Symbol
source
MINDFul.compileintent! — Method
compileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.RemoteIntent};
    verbose,
    offsettime
) -> Any
source
MINDFul.compileintent! — Method
compileintent!(
    ibnf::MINDFul.IBNFramework{A, B, C, D, MINDFul.BestEmpiricalAvailabilityCompilation} where {A, B, C, D},
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent};
    verbose,
    offsettime
) -> Symbol
source
MINDFul.compileintent! — Method
compileintent!(
    ibnf::MINDFul.IBNFramework{A, B, C, D, R} where {A, B, C, D, R<:MINDFul.KShorestPathFirstFitCompilation},
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent};
    verbose,
    offsettime
) -> Symbol
source
MINDFul.findindexglobalnode — Method
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

source
MINDFul.installintent! — Method
installintent!(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime
source
MINDFul.isbordernode — Method
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

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

Return boolean if localnode is in ibnf as a border node

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

Return boolean if globalnode is in ibnf as a border node

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

Return boolean if globalnode belongs to ibnf

source
MINDFul.remoteintent! — Method
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

source
MINDFul.removeintent! — Method
removeintent!(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime
source
MINDFul.uncompileintent! — Method
uncompileintent!(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime
source
MINDFul.uninstallintent! — Method
uninstallintent!(
    ibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime
source

Public return codes

MINDFul.ReturnCodes — Module

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.

source

Public HTTP codes

MINDFul.HTTPMessages — Module

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.

source

Non-public interface

MINDFul.OxygenServer — Type

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

source
MINDFul.AbstractOperationMode — Type

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

source
MINDFul.AvailabilityConstraint — Type
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

source
MINDFul.BasicAlgorithmMemory — Type
mutable struct BasicAlgorithmMemory
  • datetime::Dates.DateTime: The simulated (or not) current datetime. It's used by the algorithm to build the uptime/downtime data
  • logintrapaths::Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Dict{Vector{Vector{Int64}}, Int64}}: Log here the selection of (protection) path for an intra node (+ border) intent after install. Add new elements upon installation A new path Vector{Vector{LocalNode}} is added per node pair and counted how many times was it used
  • loginterupdowntimes::Dict{MINDFul.GlobalEdge, Dict{Base.UUID, MINDFul.UpDownTimesNDatetime}}: Log here the up/downtimes of border-node to cross node. Add new elements upon installation. Update entries upon compilation. All UUIDs correspond to Remote Connectivity intents
source
MINDFul.BestEmpiricalAvailabilityCompilation — Type
mutable struct BestEmpiricalAvailabilityCompilation <: MINDFul.IntentCompilationAlgorithmWithMemory

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

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

  • cachedresults::MINDFul.CachedResults: cached information

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

source
MINDFul.CachedResults — Type
struct CachedResults

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

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

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

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

source
MINDFul.ConnectivityIntent — Type
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

source
MINDFul.CrossLightpathIntent — Type
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.

source
MINDFul.EdgeProperties — Type
struct EdgeProperties
  • distance::Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}: The distance of the edge (assumed km)

An immutable description of the edge properties

source
MINDFul.EndNodeAllocations — Type
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.

source
MINDFul.IBNAttributeGraph — Type
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.
source
MINDFul.IBNFCommunication — Type
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.

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

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

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

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

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

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

  • sdncontroller::MINDFul.AbstractSDNController: SDN controller handle

  • intcompalg::MINDFul.IntentCompilationAlgorithm: Intent compilation algorithm

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

Constructor that specify IBNFHandlers to make it potentially type stable

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

The most default construct with abstract type of IBN handlers

source
MINDFul.IBNIssuer — Type
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.

source
MINDFul.IntentDAGInfo — Type
mutable struct IntentDAGInfo

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

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

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

source
MINDFul.IntentDAGNode — Type
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

source
MINDFul.IntentLogState — Type
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}}
source
MINDFul.KShorestPathFirstFitCompilation — Type
struct KShorestPathFirstFitCompilation <: MINDFul.IntentCompilationAlgorithmWithMemory

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

  • cachedresults::MINDFul.CachedResults

  • basicalgmem::MINDFul.BasicAlgorithmMemory

source
MINDFul.KShorestPathFirstFitCompilation — Method
KShorestPathFirstFitCompilation(
    ibnag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{T}, Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, MINDFul.EdgeView}, Base.UUID} where T<:MINDFul.NodeView,
    candidatepathnum::Int64
) -> MINDFul.KShorestPathFirstFitCompilation
source
MINDFul.LightpathIntent — Type
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

source
MINDFul.LightpathRepresentation — Type
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

source
MINDFul.LimitedSplitConstraint — Type
struct LimitedSplitConstraint <: MINDFul.AbstractIntentConstraint

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

source
MINDFul.NoGroomingConstraint — Type
struct NoGroomingConstraint <: MINDFul.AbstractIntentConstraint

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

source
MINDFul.NodeProperties — Type
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

source
MINDFul.NodeView — Type
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.

source
MINDFul.OXCAddDropBypassSpectrumLLI — Type
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)

source
MINDFul.OXCView — Type
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.

source
MINDFul.OpticalInitiateConstraint — Type
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

source
MINDFul.OpticalTerminateConstraint — Type
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.
source
MINDFul.ProtectedLightpathIntent — Type
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

source
MINDFul.RemoteHTTPHandler — Type
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.

source
MINDFul.RemoteIntent — Type
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

source
MINDFul.ReservableResourceView — Type

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)
source
MINDFul.ReturnCodeTime — Type
struct ReturnCodeTime

  • returncode::Symbol

  • datetime::Dates.DateTime

What most time-sensitive functions return

source
MINDFul.RouterPort — Type
struct RouterPort

A representation of a router port.

  • rate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
source
MINDFul.RouterPortLLI — Type
struct RouterPortLLI <: MINDFul.LowLevelIntent

  • localnode::Int64: Target node

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

source
MINDFul.RouterView — Type
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

source
MINDFul.SplitGlobalNode — Type
struct SplitGlobalNode

  • globalnode::MINDFul.GlobalNode

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

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

The return value from the prioritizesplitnode and prioritizesplitbordernode functions

source
MINDFul.TransmissionMode — Type
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

source
MINDFul.TransmissionModuleCompatibility — Type
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

source
MINDFul.TransmissionModuleIntent — Type
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

source
MINDFul.TransmissionModuleLLI — Type
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

source
MINDFul.TransmissionModuleView — Type
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.

source
MINDFul._rec_deletenodesedgesuntilgroomingfound! — Method
_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

source
MINDFul.addidagedge! — Method
addidagedge!(
    ibnf::MINDFul.IBNFramework,
    fromnode::Base.UUID,
    tonode::Base.UUID;
    offsettime
) -> Bool
source
MINDFul.addidagnode! — Method
addidagnode!(
    ibnf::MINDFul.IBNFramework,
    intent::MINDFul.AbstractIntent;
    parentids,
    childids,
    intentissuer,
    offsettime
) -> MINDFul.IntentDAGNode{I, MINDFul.MachineGenerated} where I<:MINDFul.AbstractIntent

Return the IntentDAGNode

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

Return the UUID

source
MINDFul.addtoinstalledlightpaths! — Method
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

source
MINDFul.addtoinstalledlightpaths! — Method
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

source
MINDFul.allocate_transmissionmodule — Method
allocate_transmissionmodule(
    ibnf::MINDFul.IBNFramework,
    dagnodeid::Base.UUID,
    localnode::Int64,
    transmissionmodulereservationentry::MINDFul.TransmissionModuleLLI
)
source
MINDFul.calcintrasplitglobalnode — Method
calcintrasplitglobalnode(
    ibnf::MINDFul.IBNFramework,
    intent::MINDFul.ConnectivityIntent,
    splitglobalnodeonly::MINDFul.GlobalNode
) -> MINDFul.SplitGlobalNode
source
MINDFul.calculateprotectedpathavailability — Method
calculateprotectedpathavailability(
    p1edges::Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}},
    p1avails::Vector{Float64},
    p2edges::Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}},
    p2avails::Vector{Float64}
) -> Float64
source
MINDFul.calculateprotectedpathavailability — Method
calculateprotectedpathavailability(
    pedges::Vector{Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}}},
    pavails::Vector{Vector{Float64}}
) -> Float64

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

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

Set verbose=true to see where the reservation fails

source
MINDFul.canreserve — Method
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

source
MINDFul.canreserve — Method
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

source
MINDFul.checkfilepath — Method
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.

source
MINDFul.checkifopensslinstalled — Method
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.

source
MINDFul.choosecrosssplitavailabilities — Method
choosecrosssplitavailabilities(
    avcon::MINDFul.AvailabilityConstraint,
    firsthalfavailability,
    secondhalfavailability,
    beacomp::MINDFul.BestEmpiricalAvailabilityCompilation
) -> Tuple{MINDFul.AvailabilityConstraint, MINDFul.AvailabilityConstraint}
source
MINDFul.choosecrosssplitavailabilities — Method
choosecrosssplitavailabilities(
    avcon::MINDFul.AvailabilityConstraint,
    firsthalfavailability,
    secondhalfavailability,
    intentcomp::MINDFul.IntentCompilationAlgorithm
) -> Tuple{MINDFul.AvailabilityConstraint, MINDFul.AvailabilityConstraint}
source
MINDFul.choosegroominornot — Method

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.

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

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

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

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

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

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

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

A template compilation function that can be extended

Give in the following hook functions:

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

It should return a Symbol as a return code. Common return codes are found in MINDFul.ReturnCodes

intradomainalgfun(
    ibnf::IBNFramework, 
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    ; 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,
) -> 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 SplitGlobalNodes with decreasing priority of which node should be chosen.

prioritizesplitbordernodes(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
) -> Vector{GlobalNode}
source
MINDFul.consecutivelightpathsidx — Method
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]
source
MINDFul.construct_BoolLogState — Function
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.

source
MINDFul.constructfromdict — Method
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.

source
MINDFul.constructfromdict — Method
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.

source
MINDFul.convertb64keytopem — Method
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".

source
MINDFul.createmultidomainIBNAttributeGraph — Method
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.

source
MINDFul.default_OXCview — Function
default_OXCview(
    nodeproperties::MINDFul.NodeProperties,
    spectrumslots::Int64
) -> MINDFul.OXCView{MINDFul.OXCDummy}
default_OXCview(
    nodeproperties::MINDFul.NodeProperties,
    spectrumslots::Int64,
    offsettime
) -> MINDFul.OXCView{MINDFul.OXCDummy}
source
MINDFul.deleteedgesuntilgroomingfound! — Method
deleteedgesuntilgroomingfound!(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
)

Delete edges towards grooming nodes.

source
MINDFul.deletenodesedgesuntilgroomingfound — Method
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

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

Implement this function to do custom actions per specific ReservableResourceView

source
MINDFul.edgeify — Method
edgeify(
    path::Vector{Int64}
) -> Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}}
source
MINDFul.emptyaggraphwithnewuuid — Method
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
source
MINDFul.estimatecrossconnectionavailability — Method
estimatecrossconnectionavailability(
    ibnf::MINDFul.IBNFramework{A, B, C, D, MINDFul.BestEmpiricalAvailabilityCompilation} where {A, B, C, D},
    srcglobalnode::MINDFul.GlobalNode,
    dstglobalnode::MINDFul.GlobalNode
)
source
MINDFul.estimateintraconnectionavailability — Method
estimateintraconnectionavailability(
    ibnf::MINDFul.IBNFramework{A, B, C, D, MINDFul.BestEmpiricalAvailabilityCompilation} where {A, B, C, D},
    srclocalnode::Int64,
    dstlocalnode::Int64
)
source
MINDFul.findconsecutiveblocks — Method
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.

source
MINDFul.firstfit — Method
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

source
MINDFul.generateRSAkeys — Method
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.

source
MINDFul.generatelightpathoxcadddropbypassspectrumlli — Method
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.

source
MINDFul.getafterlliidx — Method
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.

source
MINDFul.getafterlliidx — Method
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.

source
MINDFul.getafterlliidx — Method
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.

source
MINDFul.getbaseurl — Method
getbaseurl(
    remotehandler::MINDFul.AbstractIBNFHandler
) -> Any

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

source
MINDFul.getcurrentlinkstate — Method
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.

source
MINDFul.getdictlinkupdowntimes — Method
getdictlinkupdowntimes(
    ibnf;
    checkfirst,
    verbose,
    endtime
) -> Dict

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

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

Calculate empirical availability of a path

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

Calculate empirical availability of a protected path

source
MINDFul.getfirst — Method
getfirst(predicate::Function, ar::AbstractArray) -> Any

Returns the element is predicate is satisfied or nothing otherwise.

source
MINDFul.getfirstcompatibletransmoduleidxandmodeidx — Method
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.

source
MINDFul.getibnagweights — Method
getibnagweights(
    cr::MINDFul.CachedResults
) -> Matrix{Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}}
source
MINDFul.getibnfhandlergentoken — Method
getibnfhandlergentoken(
    remotehandler::MINDFul.AbstractIBNFHandler
) -> Any

Get the generated token for authenticating a remote domain.

source
MINDFul.getibnfhandlerperm — Method
getibnfhandlerperm(
    remotehandler::MINDFul.AbstractIBNFHandler
) -> Any

Get the established permission of a remote domain.

source
MINDFul.getibnfhandlerport — Method
getibnfhandlerport(
    remotehandler::MINDFul.AbstractIBNFHandler
) -> Int64

Get the port of the server of a remote domain.

source
MINDFul.getibnfhandlerrecvtoken — Method
getibnfhandlerrecvtoken(
    remotehandler::MINDFul.AbstractIBNFHandler
) -> Any

Get the received token for authenticating to a remote domain.

source
MINDFul.getibnfserver — Method
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.

source
MINDFul.getibnfwithid — Method
getibnfwithid(
    ibnfs::Vector{<:MINDFul.IBNFramework},
    ibnfid::Base.UUID
) -> Union{Nothing, MINDFul.IBNFramework}
source
MINDFul.getidaginfo — Method
getidaginfo(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> MINDFul.IntentDAGInfo
source
MINDFul.getidagnextuuidcounter — Method
getidagnextuuidcounter(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Base.UUID
source
MINDFul.getidagnode — Method
getidagnode(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    dagnodeid::Base.UUID
) -> MINDFul.IntentDAGNode
source
MINDFul.getidagnodechildren — Method
getidagnodechildren(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Vector{MINDFul.IntentDAGNode}
source
MINDFul.getidagnodechildren — Method
getidagnodechildren(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnode::MINDFul.IntentDAGNode
) -> Vector{MINDFul.IntentDAGNode}
source
MINDFul.getidagnodedescendants — Method
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.

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

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

source
MINDFul.getidagnodeidxsconnected — Method
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.

source
MINDFul.getidagnodeidxsdescendants — Method
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

source
MINDFul.getidagnodeleafs — Method
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.

source
MINDFul.getidagnodeleafs2install — Method
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.

source
MINDFul.getidagnodellis — Method
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

source
MINDFul.getidagnodellis — Method
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

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

source
MINDFul.getidagnodes — Method
getidagnodes(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Vector{MINDFul.IntentDAGNode}
source
MINDFul.getlinkstates — Method
getlinkstates(
    ibnf::MINDFul.IBNFramework,
    edge::Graphs.SimpleGraphs.SimpleEdge;
    checkfirst,
    verbose
) -> Any
source
MINDFul.getlinkstates — Method
getlinkstates(
    oxcview::MINDFul.OXCView,
    ed::Graphs.SimpleGraphs.SimpleEdge
) -> Vector{Tuple{Dates.DateTime, Bool}}
source
MINDFul.getlinkstates — Method
getlinkstates(
    oxcview::MINDFul.OXCView
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Tuple{Dates.DateTime, Bool}}}
source
MINDFul.getlinkupdowntimes — Method
getlinkupdowntimes(
    ibnf,
    edge;
    checkfirst,
    verbose,
    endtime
) -> MINDFul.UpDownTimes

Return the up and downtimes for the specific link

source
MINDFul.getlocalnodenum — Method
getlocalnodenum(ibnf::MINDFul.IBNFramework) -> Any

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

source
MINDFul.getloginterupdowntimes — Method
getloginterupdowntimes(
    bam::MINDFul.BasicAlgorithmMemory
) -> Dict{MINDFul.GlobalEdge, Dict{Base.UUID, MINDFul.UpDownTimesNDatetime}}
source
MINDFul.getloginterupdowntimes — Method
getloginterupdowntimes(
    intentcomp::MINDFul.IntentCompilationAlgorithmWithMemory
) -> Dict{MINDFul.GlobalEdge, Dict{Base.UUID, MINDFul.UpDownTimesNDatetime}}
source
MINDFul.getlogintrapaths — Method
getlogintrapaths(
    bam::MINDFul.BasicAlgorithmMemory
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Dict{Vector{Vector{Int64}}, Int64}}
source
MINDFul.getlogintrapaths — Method
getlogintrapaths(
    intentcomp::MINDFul.IntentCompilationAlgorithmWithMemory
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Dict{Vector{Vector{Int64}}, Int64}}
source
MINDFul.getlowestratetransmissionmode — Method
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.

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

Request topology information

source
MINDFul.getnodeindex — Method
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

source
MINDFul.getoxclliedges — Method
getoxclliedges(
    oxclli::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Vector{Graphs.SimpleGraphs.SimpleEdge{Int64}}
source
MINDFul.getpath — Method
getpath(
    lpr::MINDFul.LightpathRepresentation
) -> Vector{Vector{Int64}}
source
MINDFul.getpathdistance — Method
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
source
MINDFul.getprpath — Method
getprpath(
    prlpintent::MINDFul.ProtectedLightpathIntent
) -> Vector{Vector{Int64}}
source
MINDFul.getresidualbandwidth — Method
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

source
MINDFul.getresidualbandwidth — Method
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

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

Get the router port

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

Get the router port

source
MINDFul.getrouterportrate — Method
getrouterportrate(
    tmc::MINDFul.TransmissionModuleCompatibility
) -> Union{Nothing, Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}}
source
MINDFul.getstaged — Method
getstaged(
    nodeview::MINDFul.NodeView
) -> Union{Nothing, Set{MINDFul.TransmissionModuleLLI}}
source
MINDFul.getstaged — Method
getstaged(
    oxcview::MINDFul.OXCView
) -> Set{MINDFul.OXCAddDropBypassSpectrumLLI}
source
MINDFul.gettotalbandwidth — Method
gettotalbandwidth(
    lpr::MINDFul.LightpathRepresentation
) -> Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
source
MINDFul.getupdowntimes! — Method
getupdowntimes!(
    updowntimesndatetime::MINDFul.UpDownTimesNDatetime,
    ls::Array{Tuple{R, T}, 1}
) -> MINDFul.UpDownTimesNDatetime
getupdowntimes!(
    updowntimesndatetime::MINDFul.UpDownTimesNDatetime,
    ls::Array{Tuple{R, T}, 1},
    endtime
) -> MINDFul.UpDownTimesNDatetime

Incremeantaly update updowntimesndatetime given the new ls

source
MINDFul.getupdowntimes — Method
getupdowntimes(
    ls::Array{Tuple{R, T}, 1}
) -> MINDFul.UpDownTimes
getupdowntimes(
    ls::Array{Tuple{R, T}, 1},
    endtime
) -> MINDFul.UpDownTimes

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.

source
MINDFul.getyenpathsdict — Method
getyenpathsdict(
    cr::MINDFul.CachedResults
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Vector{Int64}}}
source
MINDFul.getyenpathsdistsdict — Method
getyenpathsdistsdict(
    cr::MINDFul.CachedResults
) -> Dict{Graphs.SimpleGraphs.SimpleEdge{Int64}, Vector{Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(km,), 𝐋, nothing}}}}
source
MINDFul.groomifllichildexists! — Method
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

source
MINDFul.handshake_init! — Method
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.

source
MINDFul.hasidagnodechildren — Method
hasidagnodechildren(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Bool
source
MINDFul.hasidagnodechildren — Method
hasidagnodechildren(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnode::MINDFul.IntentDAGNode
) -> Bool
source
MINDFul.hasidagnodeparents — Method
hasidagnodeparents(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnodeid::Base.UUID
) -> Bool
source
MINDFul.hasidagnodeparents — Method
hasidagnodeparents(
    idag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo},
    idagnode::MINDFul.IntentDAGNode
) -> Bool
source
MINDFul.increaseidagcounter! — Method
increaseidagcounter!(
    intentdag::AttributeGraphs.AttributeGraph{Int64, Graphs.SimpleGraphs.SimpleDiGraph{Int64}, Vector{MINDFul.IntentDAGNode}, Nothing, MINDFul.IntentDAGInfo}
) -> Int64
source
MINDFul.insertreservation! — Method
insertreservation!(
    sdn::MINDFul.AbstractSDNController,
    resourceview::MINDFul.ReservableResourceView,
    dagnodeid::Base.UUID,
    reservationdescription;
    verbose
) -> Symbol
source
MINDFul.insertreservationhook! — Method
insertreservationhook!(
    sdn::MINDFul.AbstractSDNController,
    oxcview::MINDFul.OXCView,
    dagnodeid::Base.UUID,
    reservationdescription::MINDFul.OXCAddDropBypassSpectrumLLI;
    verbose
) -> Symbol
source
MINDFul.insertreservationhook! — Method
insertreservationhook!(
    sdn::MINDFul.AbstractSDNController,
    resourceview::MINDFul.ReservableResourceView,
    dagnodeid::Base.UUID,
    reservationdescription;
    verbose
) -> Symbol

Implement this function to do custom actions per specific ReservableResourceView

source
MINDFul.intradomaincompilationtemplate — Method
intradomaincompilationtemplate(
;
    prioritizepaths,
    prioritizegrooming,
    prioritizerouterport,
    prioritizetransmdlandmode,
    choosespectrum,
    chooseoxcadddropport,
    offsettime
) -> MINDFul.var"#330#337"{MINDFul.var"#330#331#338"{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},
) -> 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},
) -> 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},

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

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

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

prioritizetransmdlandmode(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    node::LocalNode,
    path::Union{Nothing, Vector{LocalNode}},
    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},
    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},
    node::LocalNode
) -> Vector{Int}
source
MINDFul.intradomaincompilationtemplate_destination! — Method
intradomaincompilationtemplate_destination!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    transmissionmodulecompat,
    opticalincomingnode::Int64,
    spectrumslotsrange::UnitRange{Int64},
    prioritizerouterport::Function,
    prioritizetransmdlmode::Function,
    chooseoxcadddropport::Function,
    mena::MINDFul.MutableEndNodeAllocations;
    verbose,
    offsettime
) -> Symbol

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

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

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

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

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

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

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

chooseoxcadddropport(
    ibnf::IBNFramework,
    idagnode::IntentDAGNode{<:ConnectivityIntent},
    node::LocalNode
) -> Vector{Int}
source
MINDFul.ipfiltering — Method
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.

source
MINDFul.isaddportallocation — Method
isaddportallocation(
    oxcswitchentry::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Bool

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

source
MINDFul.isdropportallocation — Method
isdropportallocation(
    oxcswitchentry::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Bool

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

source
MINDFul.isinternalorborderintent — Method
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.

source
MINDFul.isonlyoptical — Method
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

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

Return true if oxclli is involved with failed equipment

source
MINDFul.isreservationvalid — Function
isreservationvalid(
    oxcswitchreservationentry::MINDFul.OXCAddDropBypassSpectrumLLI
) -> Union{Bool, Symbol}
isreservationvalid(
    oxcswitchreservationentry::MINDFul.OXCAddDropBypassSpectrumLLI,
    verbose::Bool
) -> Union{Bool, Symbol}
source
MINDFul.issatisfied — Method
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
source
MINDFul.issubpath — Method
issubpath(
    path::Vector{Int64},
    subpath::Vector{Int64}
) -> Bool

Return `true` if `subpath` is contained in `path`
source
MINDFul.isthesame — Method
isthesame(obj1, obj2) -> Any

Recursively compare all fields until a primitive element type is found

source
MINDFul.istransmissionmoduleandmodecompatible — Method
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.

source
MINDFul.istransmissionmoduleandmodecompatible — Method
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.

source
MINDFul.istransmissionmoduleappropriate — Method
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

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

Return true if transmissionmoduleview can support with its modes the transmissionmodulecompat

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

Return a Vector{Vector{Int}} being the lightpaths from the logical low level intent order
source
MINDFul.logicalordergetpath — Method
logicalordergetpath(
    lo::Vector{<:MINDFul.LowLevelIntent}
) -> Vector{Int64}

Return a Vector{Int} with the path given from the logical low level intent order
source
MINDFul.logicalorderissinglelightpath — Method
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)

source
MINDFul.logintrapathsandinterintents! — Method
logintrapathsandinterintents!(
    ibnf::MINDFul.IBNFramework{A, B, C, D, R} where {A, B, C, D, R<:MINDFul.IntentCompilationAlgorithmWithMemory},
    idagnode::MINDFul.IntentDAGNode
)
source
MINDFul.main — Method
main(; configfile)

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

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

Return a Dict{Edge{LocalNode}, Vector{GroomingPossibility}}

source
MINDFul.prioritizegrooming_exactly — Method
prioritizegrooming_exactly(
    ibnf::MINDFul.IBNFramework{A, B, C, D, MINDFul.BestEmpiricalAvailabilityCompilation} where {A, B, C, D},
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent};
    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.

source
MINDFul.prioritizepaths_bestempiricalavailability — Method
prioritizepaths_bestempiricalavailability(
    ibnf::MINDFul.IBNFramework{A, B, C, D, MINDFul.BestEmpiricalAvailabilityCompilation} where {A, B, C, D},
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent}
) -> Vector{Vector{Vector{Int64}}}

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

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

Same as prioritizerouterports_lowestrate but with a sort! in the end

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

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

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

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

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

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

source
MINDFul.prioritizetransmdlmode_default — Function
prioritizetransmdlmode_default(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64,
    path::Union{Nothing, Vector{Int64}},
    routerportrate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}}
) -> Vector{Tuple{Int64, Int64}}
prioritizetransmdlmode_default(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    node::Int64,
    path::Union{Nothing, Vector{Int64}},
    routerportrate::Unitful.Quantity{Float64, Data 𝐓^-1, Unitful.FreeUnits{(Gbps,), Data 𝐓^-1, nothing}},
    transmdlcompat::Union{Nothing, MINDFul.TransmissionModuleCompatibility}
) -> Vector{Tuple{Int64, Int64}}
source
MINDFul.pushstatetoidagnode! — Method
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}
source
MINDFul.pushstatetoidagnode! — Method
pushstatetoidagnode!(
    idagnode::MINDFul.IntentDAGNode,
    intentstate::MINDFul.IntentState.T;
    offsettime
) -> Vector{Tuple{Dates.DateTime, MINDFul.IntentState.T}}
source
MINDFul.readb64keys — Method
readb64keys(finalkeyfile::String) -> String

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

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

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

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

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

source
MINDFul.requestcompileintent_init! — Function
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

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

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

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

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

source
MINDFul.requestcurrentlinkstate_init — Method
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

source
MINDFul.requestcurrentlinkstate_term — Method
requestcurrentlinkstate_term(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    ge::MINDFul.GlobalEdge
) -> Union{Nothing, Bool}
source
MINDFul.requestdelegateintent_init! — Method
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

source
MINDFul.requestdelegateintent_init! — Method
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

source
MINDFul.requestglobalnodeelectricalpresence_init — Method
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

source
MINDFul.requestibnattributegraph_init — Method
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

source
MINDFul.requestibnattributegraph_term! — Method
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.

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

Request the handlers of the handler

source
MINDFul.requestidag_init — Method
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

source
MINDFul.requestinstallintent_init! — Method
requestinstallintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime
source
MINDFul.requestinstallintent_term! — Method
requestinstallintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime
source
MINDFul.requestintentgloballightpaths_init — Method
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

source
MINDFul.requestintentglobalpath_init — Method
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

source
MINDFul.requestintentglobalpath_term — Method
requestintentglobalpath_term(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    intentuuid::Base.UUID;
    onlyinstalled
) -> Vector
source
MINDFul.requestissatisfied_init — Method
requestissatisfied_init(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    onlyinstalled,
    noextrallis,
    choosealternativeorder
) -> Any

Request to remoteibnf whether the idagnode is theoretically satisfied

source
MINDFul.requestissatisfied_init — Method
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

source
MINDFul.requestlinkstates_init — Method
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

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

Request logical low level intent sequence

source
MINDFul.requestremoteintentstateupdate_init! — Method
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

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

Request to set the state of the neighboring link

source
MINDFul.requestsetlinkstate_term! — Method
requestsetlinkstate_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    ge::MINDFul.GlobalEdge,
    operatingstate::Bool;
    offsettime
) -> Union{Nothing, MINDFul.ReturnCodeTime}
source
MINDFul.requestspectrumavailability_init! — Method
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

source
MINDFul.requestspectrumavailability_init! — Method
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

source
MINDFul.requestuncompileintent_term! — Method
requestuncompileintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> Symbol
source
MINDFul.requestuninstallintent_init! — Method
requestuninstallintent_init!(
    myibnf::MINDFul.IBNFramework,
    remoteibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime
source
MINDFul.requestuninstallintent_term! — Method
requestuninstallintent_term!(
    remoteibnfhandler::MINDFul.AbstractIBNFHandler,
    myibnf::MINDFul.IBNFramework,
    idagnodeid::Base.UUID;
    verbose,
    offsettime
) -> MINDFul.ReturnCodeTime
source
MINDFul.reserve! — Method
reserve!(
    sdn::MINDFul.AbstractSDNController,
    resourceview::MINDFul.ReservableResourceView,
    lowlevelintent::MINDFul.LowLevelIntent,
    dagnodeid::Base.UUID;
    checkfirst,
    verbose
) -> Symbol
source
MINDFul.reserveunreserveleafintents! — Method
reserveunreserveleafintents!(
    ibnf::MINDFul.IBNFramework,
    idagnodeleaf::MINDFul.IntentDAGNode,
    doinstall::Bool;
    verbose,
    offsettime
) -> Bool

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

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

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

source
MINDFul.rsaauthentication_init — Method
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.

source
MINDFul.sendrequest — Method
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.

source
MINDFul.setadddropport! — Method
setadddropport!(
    ena::MINDFul.MutableEndNodeAllocations,
    intval::Union{Nothing, Int64}
) -> Union{Nothing, Int64}
source
MINDFul.setdatetime! — Method
setdatetime!(
    intcompalg::MINDFul.BasicAlgorithmMemory,
    currentdatetime::Dates.DateTime
) -> Dates.DateTime
source
MINDFul.setdatetime! — Method
setdatetime!(
    intcompalg::MINDFul.IntentCompilationAlgorithm,
    currentdatetime::Dates.DateTime
) -> Dates.DateTime
source
MINDFul.setibnfhandlergentoken! — Method
setibnfhandlergentoken!(
    remotehandler::MINDFul.AbstractIBNFHandler,
    generatedtoken::String
) -> String

Set the generated token for authenticating a remote domain.

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

Set the received token for authenticating to a remote domain.

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

Set the RSA secret for authenticating a remote domain.

source
MINDFul.setibnfserver! — Method
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.

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

Set the link state on both OXCView ends of edge

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

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

source
MINDFul.setlocalnode! — Method
setlocalnode!(
    ena::MINDFul.MutableEndNodeAllocations,
    intval::Union{Nothing, Int64}
) -> Union{Nothing, Int64}
source
MINDFul.setoxcviewlinkavailabilities! — Method
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

source
MINDFul.splitandcompilecrossdomainconnectivityintent — Method
splitandcompilecrossdomainconnectivityintent(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intradomainalgfun::Function,
    splitbordernode::MINDFul.SplitGlobalNode,
    cachedintentresult::Dict{MINDFul.ConnectivityIntent, Symbol};
    verbose,
    offsettime
) -> Symbol
source
MINDFul.splitandcompileintradomainconnecivityintent! — Method
splitandcompileintradomainconnecivityintent!(
    ibnf::MINDFul.IBNFramework,
    idagnode::MINDFul.IntentDAGNode{<:MINDFul.ConnectivityIntent},
    intradomainalgfun::Function,
    splitglobalnode::MINDFul.SplitGlobalNode,
    cachedintentresult::Dict{MINDFul.ConnectivityIntent, Symbol};
    verbose,
    prioritizegrooming,
    prioritizesplitnodes,
    prioritizesplitbordernodes,
    maximumsplitlevel,
    offsettime
)

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

source
MINDFul.stage! — Method
stage!(
    resourceview::MINDFul.ReservableResourceView,
    lli::MINDFul.LowLevelIntent;
    verbose
) -> Symbol
source
MINDFul.stageaddidagnode! — Method
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.

source
MINDFul.stageunstageleafintent! — Method
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.

source
MINDFul.startibnserver! — Method
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.

source
MINDFul.unreserve! — Method
unreserve!(
    sdn::MINDFul.AbstractSDNController,
    resourceview::MINDFul.ReservableResourceView,
    dagnodeid::Base.UUID;
    verbose
) -> Symbol
source
MINDFul.unstage! — Method
unstage!(
    resourceview::MINDFul.ReservableResourceView,
    lli::MINDFul.LowLevelIntent;
    verbose,
    about2install
) -> Symbol
source
MINDFul.updateidagnodestates! — Function
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.

source
MINDFul.updatelogintentcomp! — Method
updatelogintentcomp!(
    ibnf::MINDFul.IBNFramework{A, B, C, D, R} where {A, B, C, D, R<:MINDFul.IntentCompilationAlgorithmWithMemory};
    offsettime
)
source
MINDFul.@logtime — Macro

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

source
MINDFul.@passtime — Macro

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.

source
MINDFul.@recvtime — Macro

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.

source
MINDFul.@returnfalseiffalse — Macro

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.

source
MINDFul.@returniffalse — Macro

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

source
MINDFul.@returnwtimeiffalse — Macro

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

source