Routing Control Functions

Comments

Comments begin with a hash tag (#) character and continue to the end of the line. Comments can be placed anywhere in the code.

# This comment appears before a function
function DENY_ALL() {
   # comments can appear inside functions too!
   return false;   # This function always returns false
}

Functions

The function syntax has the following format:

function <FUNCTION_NAME>() {
# statements 
}

A function name can only contain letters, a-z, A-Z, numbers 0-9, and the underscore ( _ ) character and must start with a letter or an underscore.

Valid Name Examples

• MY_FUNCTION_11
• MyFunction11
• _good_function_11

Invalid Name Examples

• 9badFunctionName
• Bad Function Name
• -Bad-Function-Name

Function Calls

An RCF function (callee) can be called from another RCF function (caller), and an RCF function call can be used as part of an expression.

<CALLEE_FUNCTION_NAME>();

For example, the RCF function call has the following syntax:

function SET_MED() { med = 100; }

function ACCEPT_ALL() { return true; }

function CALLER() { return local_preference is 10 or ACCEPT_ALL(); }

When used as a standalone statement, it must be followed by a semicolon (;).

function SET_MED() { med = 100; }

function CALLER() {
   SET_MED();
   return true;
}

Function Arguments

RCF functions can optionally accept one or more comma-separated arguments. Functions that accept arguments cannot apply to a point of RCF application.

Define a function argument using one of the following:

• Argument Type
• Argument Name

An argument name must start with a dollar ($) sign followed by letters, a-z, A-Z, numbers 0-9 and the underscore ( _ ) character, such as $GoodArgument or $Good_Argument_11.

Apply functions that accept arguments at some points of the RCF application.

Functions reference arguments by name only and can be used in any of the following ways:

• To the right of a comparison operation
• To the left of a comparison operation
• To the right of a modification operation
• As an argument to a function call

In addition, a trilean type function argument can be used inside of logical and sequential expressions or as a return or exit value.

Use function arguments in the body of the function that defines them. For example,

function SET_MED( int_type $arg ) {
   med = $arg;
}

An RCF function (caller) calling another RCF function that expects arguments (callee) must satisfy the following requirements:

• Number of passed arguments equals the number of callee arguments.
• Arguments passed in order.
• Caller argument types compatible with the expected argument types of the callee.

Example

Passing an immediate value as a function argument:

function SET_MED( int_type $arg, prefix_list_type $list ) {
    if prefix match $list {
       med = $arg;
    }
}

function CALLER() {
    SET_MED( 100, prefix_list_v4 KNOWN_V4_PREFIXES );
    SET_MED( 100, prefix_list_v6 KNOWN_V6_PREFIXES );
    return true;
}

Example

Passing an attribute as a function argument:

function PREPEND_ATTRIBUTE_REPEAT_4( as_number_type $arg ) {
    as_path prepend $arg $arg $arg $arg;
}

function CALLER() {
    PREPEND_ATTRIBUTE_REPEAT_4( med );
    return true;
}

Example

Passing another function argument as a function argument:

function FUNC_C( int_type $arg ) {
    local_preference = $arg;
}

function FUNC_B( int_type $arg ) {
    FUNC_C( $arg );
}

function FUNC_A() {
    FUNC_B( 100 );
    return true;
}
            

Trilean Logic States

RCF functions support true, false, and unknown as trilean values.

Expressions

RCF functions use expressions composed of clauses of the following types:

• Comparisons
  • local_preference is 100
• Match operations
  • prefix match prefix_list_v4 ALLOW_ROUTES
• Function calls
  • DEFAULT_ROUTE()
• Sequential operator expressions
  • FUNC_A() ?? FUNC_B() ?? true

Fallback Operator

<FUNC1_NAME() fallback <FUNC2_NAME>() 

Logical Operators

Combine expressions using logical operators such as and, or, and not to form complex expressions. Use parentheses () for grouping and setting precedence. The RCF evaluation engine evaluates the expression from left to right and honors the decreasing precedence of the evaluation:

• parentheses "( )"
• not
• and
• or

Examples

• local_preference is 100
• not prefix match prefix_list_v4 PREFIX_LIST_NAME
• DEFAULT_ROUTE() and ( local_preference >= 100 and community match community_list COMM_LIST ) or $arg

The not operator inverts the result of an expression.

Example

not prefix match prefix_list_v4 PREFIX_LIST_NAME

If the left operand of an and operation evaluates to false or unknown, no evaluation of the second operand occurs.

The and operator combines expressions so that both expressions must evaluate to true for the entire expression to evaluate to true.

If the left operand of an or operation evaluates to true, no evaluation of the second operand occurs.

The or operator combines expressions so that either of the expressions must evaluate to true for the entire expression to evaluate to true.

Sequential Operators

The sequential operator, ?? allows the conditional evaluation of functions in a sequence and has the following syntax:

<FUNC1_NAME>() ?? <FUNC2_NAME>()

The operator can be repeated to form longer sequences of function invocations:

<FUNC1_NAME>() ?? <FUNC2_NAME>() ?? <FUNC3_NAME>() ?? <FUNC4_NAME>()

The sequential operator evaluates the first function and takes one of the following actions:

1. If the function invocation returns true, the evaluation of the expression terminates and the entire expression returns true.
2. If the function invocation returns false, the evaluation of the expression terminates and the entire expression returns false.
3. If the function invocation returns unknown, the sequential operator proceeds to the next function and repeats.

In summary, if a function cannot return a true or false decision, but returns an unknown decision, then the evaluation process proceeds to the next function. When the process reaches the last function in the sequence, the expression returns the value from the last function. For example,

function PEER_192_168_1_1_IN() {
   ### RCF function for peer 192.168.1.1.

     # If FUNC_GLOBAL() returns true (or false), accept (or reject) the
     # route immediately.
     # Otherwise, if FUNC_ASN100() returns true (or false), accept (or
     # reject) the route immediately.
     # Otherwise, return the result from evaluating FUNC_192_168_1_1_IN().
     return FUNC_GLOBAL() ?? FUNC_ASN100() ?? FUNC_192_168_1_1_IN();
}

The trailing term can be true, false, unknown or a trilean logic state. This allows defining the default return value when all function invocations return unknown.

function PEER_192_168_1_1_IN() {
    ### RCF function for peer 192.168.1.1.

    # If the 3 function calls don't return an an explicit true or false,
    # accept the route.
    return FUNC_GLOBAL() ?? FUNC_ASN100() ?? FUNC_192_168_1_1_IN() ?? true;
}

function PEER_192_168_1_2_IN( trilean_type $arg ) {
    ### RCF function for peer 192.168.1.2.
    return FUNC_GLOBAL() ?? FUNC_ASN100() ?? FUNC_192_168_1_2_IN() ?? $arg;
}

Comparing Sequential Expressions, Logical and Expressions, Logical or Expressions, and Statements

Use the four syntaxes with the sequential operator ??, and, or, and functions in statements with (;) to achieve different goals with function invocations. The following table illustrates the difference between the functions:

function SEQ_OP() {
   return FUNC1() ?? FUNC2();
}

function AND() {
   return FUNC1() and FUNC2();
}

function OR() {
   return FUNC1() or FUNC2();
}

function STMT() {
            FUNC1();
            return FUNC2();
}

Numerical Operators

Modification operators on numerical attributes do not allow the result to exceed the range of values valid for the attribute. For example, the result of local_preference += 100 becomes bounded by 4294967295 and med -= 10000 becomes bounded by 0.

Return Statements

The return statement returns the provided immediate value or the result from evaluating the provided expression to the caller.

return true | false | unknown | <ARGUMENT> | <EXPRESSION>;

The return statement requires a semicolon (;) at the end of the statement.

Example

function ALWAYS_TRUE() {
    # Example of returning an immediate value
    return true;
}

function DEFAULT_ROUTE() {
    # Example of returning a comparison
    return prefix is 0.0.0.0/0;
}

function RETURN_EXPR() {
    # Example of returning the result of an expression
    return ALWAYS_TRUE() and DEFAULT_ROUTE();
}

function RETURN_ARGUMENT( trilean_type $arg ) {
    # Example of returning an argument
    return $arg;
}

Exit Statements

The exit statement immediately stops the RCF evaluation and returns the provided immediate value or the result from evaluating the provided expression to the point of application. Use this value at the point of application to accept or reject the route.

exit true | false | unknown | <EXPRESSION>;

Examples

function MAYBE_EXIT_TRUE() {
    # Example of function that may immediately exit true
    if prefix is 1.2.3.0/24 {
        exit true;
    }
}

function MAYBE_SET_MED() {
    # If MAYBE_EXIT_TRUE() exits, med does not set and the policy evaluates to
    # true even though we do not explicitly handle it.
    MAYBE_EXIT_TRUE();
    med = 10;
    return false;
}

Attribute Modification Statements

Attribute modification statements use the following syntax:

<ATTRIBUTE> <OPERATION> <VALUE>;

The statement requires a semicolon (;) at the end.

if Conditions

RCF allows an if construct followed by an optional else if and concluding with an optional else clause.

An if syntax without an else block:

if <EXPRESSION> {
    # if block
}

An if syntax with an else block:

if <EXPRESSION>  {
    # if block
} else {
    # else block
}

An if syntax with an else if block:

if <EXPRESSION1>  {
    # if block
} else if <EXPRESSION2>  {
    # else if block
} else {
    # else block
}

Immediate Values

asdot notation

For operations that include AS number immediate values, four (4) byte AS numbers can be given in the asdot notation specified in RFC5396. For example,

as_path.origin_as is 1.10

Bandwidth Values

For operations that include bandwidth values, immediate values can be expressed as a number immediately followed by a unit. Supported units include bps, Bps, Kbps, Mbps, Gbps, KBps, MBps, and GBps. For example,

ecmp.aggregate_link_bandwidth is 200GBps
ecmp.aggregate_link_bandwidth >= 12.25Mbps

MAC Address Notation

For operations that include MAC addresses, immediate values can use colon or dot notation. For example,

evpn.mac_ip_route.mac_address is 1a:2b:3c:4d:5e:6f
evpn.mac_ip_route.mac_address is 1a2b.3c4d.5e6f

Ethernet Segment Identifier Notation

For operations that include Ethernet Segment Identifiers, structure immediate values as 5 groups of 4 hex characters each, delimited by colons. For example,

evpn.mac_ip_route.esi is AAAA:BBBB:CCCC:DDDD:EEEE

Sets

RCF functions support a set collection. A set consists of a collection of unique values. When multiple instances of the same value appear, only one takes effect.

community add { 100, 200, 300 }
community add { 100, 200, igp.tag }

Ranges

RCF supports a range construct with a lower and upper bound value. A value matches against a range if the following parameters true:

• The parameter has a value greater than or equal to the lower bound value.
• The parameter has a value less than or equal to the upper bound value.

If the lower bound value has a greater value than the upper bound value in a given range, no value matches against it. A range can be defined as part of a set collection. For example,

as_path.origin_as in { 64500, 64505 to 64510, 64503, 64515 to 64520 }

Attributes and Functions

The RCF function language provides a list of supported attributes that can be compared against values or modified. The language also includes built-in functions that provide some predefined functionality.

External References to EOS Policy Constructs

The RCF function can refer to policy constructs in the running config external to the RCF configuration called external references. Examples include AS path lists (as_path_list), route origin authorization (ROA) tables (roa_table), community lists (community_list), and extended/large community lists.

Refer to the following examples:

return prefix match prefix_list_v4 TEST_PREFIX_LIST;

community add community_list TEST_COMM_LIST;

Define the policy constructs in the running config before referencing them in an RCF Function.

External Reference Compilation Checks

The command rcf external reference unconfigured action error command in the Router General Configuration Mode directs the RCF compiler to treat missing external references as compilation errors in all RCF configuration workflows.

switch(config)# router general
switch(config-router-general)# command rcf external reference unconfigured action error

EOS disables this feature by default. When disabled, the RCF compiler treats missing external references as errors in interactive workflows such as configuring from the CLI or using configure sessions, and ignores missing external references in non-interactive workflows such as copying or replacing configurations. The following table provides a description of RCF behavior across various workflows:

Using the input Attribute Scope

The RCF evaluation engine provides access to the unmodified attribute values, as seen by the evaluation engine at the point of application, during the evaluation of the function.

router general
    control-functions
       code
       function INPUT_AND_MODIFIED_LP_CHECK() {
          return input.local_preference is 500 and
                 local_preference is 1000;
       }
                
       function INBOUND_POLICY() {
          local_preference = 1000;
          return INPUT_AND_MODIFIED_LP_CHECK();
       }
       EOF
!

In the example, local_preference modifies to 1000 for all paths in the INBOUND_POLICY(). However, INPUT_AND_MODIFIED_LP_CHECK() returns true only if thelocal_preference value at the start of the RCF evaluation has a value of 500.

Built-in Functions

The help function FUNCTION_NAME command displays information about a specified built-in function. For example, the help function set_next_hop_self displays the following output:

switch(config-router-general-control-functions)# help function set_next_hop_self
# set_next_hop_self
The set_next_hop_self function sets the NEXT_HOP to self for BGP advertisements. This unsets the value of the next_hop attribute.
This function is supported for IPv4 paths advertised out to peers with extended next hop support (RFC5549) negotiated.

## Return value
Type: trilean_type
This function returns true if it's invoked at a supported point of application, otherwise false.

## Example
function EXAMPLE() {
   return set_next_hop_self();
}

Adding RCF Function Code to the EOS Configuration

Use the following commands to add RCF function code to a pending buffer:

• edit - Write RCF function code using Nano, a built-in text editor.
• pull - Load RCF function code from a file.
• code - Provide RCF function code directly from the CLI.
• compile - Compile the RCF function code in the pending buffer of the CLI.
• commit - Commit the RCF function code in the pending buffer of the CLI into the running configuration after successfully compiling the code.

Use the following workflow to add the RCF Function configuration:

Modifying RCF Function Code

To modify the RCF function code, push the RCF function code to an external source where you can edit the code, and then pull the modified code into the pending buffer. Next, compile the code successfully and commit the successfully compiled code to the running-configuration.

Working with RCF Function Code Units

Organize RCF function code into named code units which consist of zero or more RCF functions. RCF function code units provide the smallest unit of RCF function configuration that you can commit to the running configuration. After compiling the RCF function code units, run the commit command to update all modified code units in the running configuration. RCF function code units have the following properties:

• Functions in one code unit may invoke functions in another code unit.
• Function names must be unique across all code units.

The following code example displays the usage of RCF function code units:

router general
    control-functions
        code unit COMMON
        function DEFAULT_ROUTE() {
            return prefix is 0.0.0.0/0 or prefix is ::/0;
        }
        EOF
        code unit AS_65535_FUNCTIONS
        function AS_65535_IN() {
            # Rejects default route, accepts all other routes
            if DEFAULT_ROUTE() {
               return false;
            }
            return true;
        }

        function AS_65535_OUT() {
            # Add a community and advertise all routes
            community add { 64500:200 };
            return true;
        }
EOF

RCF Configuration Examples

Once RCF code units commit to the running configuration, they appear in the show running-config output. This preserves the ease of provisioning devices by EOS and keeps all system configurations in a single file.

Pulling, Compiling, and Committing an RCF Code Unit Example

The following example demonstrates RCF pulling, compiling, and then committing two RCF code units to a switch:

switch(config)# router general
Arista(config-router-general)# control-functions
Arista(config-router-general-control-functions)# pull unit A replace http://192.168.1.1/rcf-code-unit-a.txt
Arista(config-router-general-control-functions)# pull unit B replace http://192.168.1.1/rcf-code-unit-b.txt
Arista(config-router-general-control-functions)# compile
Compilation successful
Arista(config-router-general-control-functions)# commit
Arista(config-router-general-control-functions)#

The router general command enters the Router General Configuration Mode, and the control-functions command enters the Control Functions Configuration Mode. The two pull commands retrieve the RCF code unit text from the specified locations. The compile command processes the RCF code units successfully, and the commit command puts the configuration into the running-config file.

Modifying and Committing an RCF Code Unit Example

The following example demonstrates taking an RCF code unit from the running-config file, modifying it, addressing any compilation errors, and committing the RCF code unit to the running-config file.

switch(config)# router general
switch(config-router-general)# control-functions
switch(config-router-general-control-functions)# push unit A flash:rcf-code-unit-a.txt
switch(config-router-general-control-functions)# bash vi /mnt/flash/rcf-code-unit-a.txt   ! edit the contents
switch(config-router-general-control-functions)# pull unit A replace flash:rcf-code-unit-a.txt
h(config-router-general-control-functions)# compile
% Error (syntax): line 1:13: mismatched input '{' expecting '('
switch(config-router-general-control-functions)# push unit A flash:rcf-code-unit-a.txt   ! optionally push the RCF code unit again
switch(config-router-general-control-functions)# bash vi /mnt/flash/rcf-code-unit-a.txt   ! edit the contents to fix compilation errors
switch(config-router-general-control-functions)# pull unit A replace flash:rcf-code-unit-a.txt
switch(config-router-general-control-functions)# compile
Compilation successful
switch(config-router-general-control-functions)# commit
switch(config-router-general-control-functions)#

The router general command enters the Router-General Configuration Mode, and the control-functions command enters the Control-Functions Configuration Mode. The push command pushes the code unit to an external file, then executing the bash command allows editing of the code unit.The two pull commands retrieve the RCF code unit text from the specified location. The compile command runs unsuccessfully and exposes an error in the syntax of the code.

The next two commands push the RCF code to the specified destination where you can modify and fix any errors. The next pull command retrieves the corrected file and then the compile command reruns the compilation of the new code successfully. The modified RCF code unit replaces the previous code in the running-config.

Modifying an RCF Code Unit in the CLI

Add and modify RCF code units directly from the CLI using the edit unit unit_name command to open the GNU Nano text editor with the specified RCF code unit content or create a new one. Saving the file and closing the editor writes the content to the pending buffer.

switch(config)# router general
switch(config-router-general)# control-functions
switch(config-router-general-control-functions)# edit unit A
! edit the contents of a code unit
switch(config-router-general-control-functions)# compile
Compilation successful
switch(config-router-general-control-functions)# commit
switch(config-router-general-control-functions)#

The router general command enters the Router-General Configuration Mode, and the control-functions command enters the Control-Functions Configuration Mode. The edit unit A command opens the Nano editor to edit or add RCF code unit text. Once saved to the buffer, the compile command compiles the code and then the commit command adds the RCF code unit to the running-config.

Replacing the RCF Configuration

Use the configure replace url to replace the running configuration with contents from the specified URL. If the configuration from the URL fails to compile, the entire configure replace fails to complete and generates an error log at the end of the command execution.

Copying the RCF Configuration

Use the copy src_url running-config and copy src_url session-config commands to replace the full RCF code at the destination with the RCF code available at the source if the code compiles successfully. If the RCF code does not compile successfully, EOS ignores the configuration from the source URL. Compilation errors in the RCF code do not affect the copying of other configuration parameters present at the source.

Missing Semicolon

router general
   control-functions
      code unit COMPILATION_ERROR
      function SET_MED() {
         med = 10
         return true;
      }
      EOF

When compiled, the output contains the following error message:

% Error unit COMPILATION_ERROR line 2:17: missing ';'
2          med = 10
                   ^
3          return true;

Missing Curly Brace

router general
   control-functions
      code unit COMPILATION_ERROR
      function CHECK_MED() {
         return med is 10;
      function SET_MED() {
         med = 10;
      }
      EOF

When compiled, the output contains the following error message:

% Error unit COMPILATION_ERROR line 3:6: missing '}' at 'function SET_MED'
2          return med is 10;
3       function SET_MED() {
        ^~~~~~~~~~~~~~~~

Missing Operator

If an expression lacks an operator, RCF cannot determine how to process the function. The following example has a expression without an operator between the attribute med and the value 10.

router general
   control-functions
      code unit COMPILATION_ERROR
      function CHECK_MED() {
         return med 10;
      }
      EOF

When compiled, the output contains the following error message:

% Error unit COMPILATION_ERROR line 2:20: no viable alternative at input 'med 10'
2          return med 10;
                      ^~

Mismatching Types

The left and right side of an RCF operator must have interoperable types for the operator. The following example has a expression that compares a community set with an integer.

router general
   control-functions
      code unit COMPILATION_ERROR
      function CHECK_COMMUNITY() {
         return community is 10;
      }
      EOF

When compiled, the output contains the following error message:

% Error unit COMPILATION_ERROR line 2:16 (function 'CHECK_COMMUNITY'): invalid operation 'is' between 'community_type' and 'int_type'
2          return community is 10;
                  ^~~~~~~~~~~~~~~

Mismatching Set Contents

An RCF must contain values with interoperable types. The following expressions defines a community set with invalid values or values from other set types.

router general
   control-functions
      code unit COMPILATION_ERROR
      function SET_COMMUNITY() {
         community = { MINE,  100, 200, 300, LINK-BANDWIDTH-AS:101:100.101MBps, 
                       LEVEL2, 100:100:100
         };
      }
      EOF

When compiled, the output contains the following error message:

% Error unit COMPILATION_ERROR line 2:23 (function 'SET_COMMUNITY'): invalid immediate values '{MINE, LINK-BANDWIDTH-AS:101:100.101MBps, LEVEL2, 100:100:100}' in an immediate community set
2          community = { MINE,  100, 200, 300, LINK-BANDWIDTH-AS:101:100.101MBps,
                         ^~~                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3                        LEVEL2, 100:100:100
                         ^~~~~~  ^~~~~~~~~~~
4          };

Undefined Reference

router general
   control-functions
      code unit COMPILATION_ERROR
      function SET_AS_PATH() {
        aspath prepend 10;
      }
      EOF

When compiled, the output contains the following error message:

% Error unit COMPILATION_ERROR line 2:8 (function 'SET_AS_PATH'): undefined reference to attribute 'aspath'
2         aspath prepend 10;
          ^~~~~~

Function Redefinition

For an RCF expression, define a function only once. The following expression defines two functions with the same name.

router general
   control-functions
      code unit FIRST_DEFINITION
      function CHECK_MED() {
         if med is 10 {
            return true;
         }
      }
      EOF
      code unit SECOND_DEFINITION
      function CHECK_MED() {
         if med is 20 {
            return false;
         }
      }
      EOF

When compiled, the output contains the following error message:

% Error unit FIRST_DEFINITION line 1:6: redefinition of function 'CHECK_MED'
1       function CHECK_MED() {
        ^~~~~~~~~~~~~~~~~~

Previously defined in code unit SECOND_DEFINITION:
1       function CHECK_MED() {
        ^~~~~~~~~~~~~~~~~~

Function Call Cycles

An RCF function cannot directly or indirectly call itself as displayed in the following expression:

router general
   control-functions
      code unit UNIT_A
      function A() {
         return B();
      }
      EOF
      code unit UNIT_B
      function B() {
         return true or C();
      }
      EOF
      code unit UNIT_C
      function C() {
         if ( false or A() or false) {
            return true;
         }
      }
      EOF

When compiled, the output contains the following error message:

% Error: cycle found in function callgraph 'A -> B -> C -> A'
Code unit UNIT_A
1       function A() {
        ^~~~~~~~~~

2          return B();
                  ^~~

Code unit UNIT_B
1       function B() {
        ^~~~~~~~~~

2          return true or C();
                          ^~~

Code unit UNIT_C
1       function C() {
        ^~~~~~~~~~

2          if ( false or A() or false) {
                         ^~~

Code unit UNIT_A
1       function A() {
        ^~~~~~~~~~

Displaying Pending RCF Function Configurations

The show router rcf pending command in the Global Configuration Mode or the show pending in the Router General Control Functions Configuration Mode displays the contents of the CLI session pending buffer. The output also displays the source of the RCF code unit pull at the top of the uncommitted RCF code.

These commands also display the contents of all RCF code units that take effect after committing the code. The output displays all code units whether or not changes have occurred in the pending buffer.

If the code has no pending changes to commit, the output displays the message, No pending routing control function changes at the top of the show command output.

switch(config)# router general
switch(config-router-general)# control-functions
switch(config-router-general-control-functions)# pull unit A replace flash:rcf-code-unit-a.txt
switch(config-router-general-control-functions)# show pending
code unit A
! Source: file:/tmp/rcf-code-unit-a.txt
function ACCEPT_ALL() {
    # Accepts all routes
    return true;
}

function DENY_ALL() {
    # Rejects all routes
    return false;
}
EOF

switch(config-router-general-control-functions)# compile
Compilation successful
switch(config-router-general-control-functions)# commit
switch(config-router-general-control-functions)# show pending
 No pending routing control function changes
code unit A
! Source: file:/tmp/rcf-code-unit-a.txt
function ACCEPT_ALL() {
    # Accepts all routes
    return true;
}

function DENY_ALL() {
    # Rejects all routes
    return false;
}
EOF
switch(config-router-general-control-functions)#

Displaying the Difference between the Pending Buffer and the Running Configuration

The show diff command in the Router General Control Functions Configuration Mode displays the difference between the RCF Function code units in the pending buffer and the RCF Function code units in the running-config.

switch(config-router-general-control-functions)# pull unit A replace file:/tmp/rcf-code-unit-a-2.txt
switch(config-router-general-control-functions)# compile
Compilation successful
switch(config-router-general-control-functions)# show diff
--- running-config: code unit A
+++ pending: code unit A
@@ -7,3 +7,7 @@
        # Rejects all routes
        return false;
}
+
+function DEFAULT_ROUTE() {
+   return prefix is 0.0.0.0/0 or prefix is ::/0;
+}

switch(config-router-general-control-functions)#

Displaying an Active RCF Configuration

The show active command in the Router General Control Functions Configuration Mode displays the configured RCF Function code units in the running-config.

switch(config-router-general-control-functions)# show active
router general
    control-functions
        code unit A source pulled-from flash:rcf-code-unit-a.txt
        code unit A
        function ACCEPT_ALL() {
            # Accepts all routes
            return true;
        }

        function DENY_ALL() {
            # Rejects all routes
            return false;
        }
        EOF
switch(config-router-general-control-functions)#

Displaying RCF Code Units

The show router rcf code unit unit_name command in the Router General Control Functions Configuration Mode displays the committed RCF code units in the running-config. RCF code units committed in a configure session only display when the configure session commits changes.

switch(config-router-general-control-functions)# show router rcf code unit A
function ACCEPT_ALL() {
    # Accepts all routes
    return true;
}

Displaying RCF Functions

The show router rcf function func_name command displays the committed RCF function definition in the running configuration. The RCF functions committed in a config session display only after committing the config session.

Example

Configure the following RCF functions and then display the configuration. Specifying a built-in function or a non-existent function returns an error.

router general
    control-functions
        code
        function testA() {  
        med = 10;  
        return true;  
    }

    EOF
    code unit unit2
    function testC() {  
    med = 20;  
    return true;  
    }

    function testB() {  
    med = 30;  
    return true;  
    }

    EOF
    code unit unit3
    function testD() {  
    return true;  
    }
    EOF

Use the following commands to display the functions:

Arista(config-router-general-control-functions)# show router rcf function testA
function testA() {
    med = 10;
    return true;
}
Arista(config-router-general-control-functions)# show router rcf function testB
function testB() {
    med = 30;
    return true;
}
Arista(config-router-general-control-functions)# show router rcf function testC
function testC() {
    med = 20;
    return true;
}
Arista(config-router-general-control-functions)# show router rcf function testD
function testD() {
    return true;
}
            

Displaying RCF Function Locations

The show router rcf function location function function_name unit unit_name command displays the code unit name and starting line number within the code unit for committed RCF function definitions.

Sample RCF Function Configuration

router general
    control-functions
       code
       function testA() {  
           med = 10;  
           return true;  
       }

       EOF
       code unit unit2
       function testC() {  
          med = 20;  
          return true;  
       }

       function testB() {  
          med = 30;  
          return true;  
       }

       EOF
       code unit unit3
       function testD() {  
           return true;  
       }
       EOF

The show output displays all RCF functions across all code units:

switch(config-router-general-control-functions)# show router rcf function location
Function Name Code Unit         Line Number  
------------- ----------------- -----------  
testA         unnamed code unit           1  
testB         unit2       6  
testC         unit2       1  
testD         unit3       1

Locate all functions in an RCF code unit by adding the unit unit_name filter to the command

switch(config-router-general-control-functions)# show router rcf function location unit unit2
Function Name Code Unit Line Number  
------------- --------- -----------  
testB         unit2               6  
testC         unit2               1

Router General Configuration Mode

Router Control Functions Commands

Show Commands

Configuring RCF for BGP Points of Applications

RCF functions filter routes and update route attributes at different points of application in BGP.

Configuring an Instance

The following configuration statements allow filtering and modifying path attributes while instantiating IPv4 Unicast and IPv6 Unicast AFI/SAFI paths from the respective sources such as the RIB, VPN AFI/SAFI, and more.

Redistribute Statement

router bgp ASN
   [ vrf NAME ]
     redistribute connected rcf FUNCTION_NAME()

router bgp 64500
   redistribute connected rcf CONNECTED_POLICY()

MPLS L3 VPN import

The IMPORT_FUNCTION_NAME() function applies to the unicast route created on import. The unicast route attributes populate with the BGP Customer Attribute Set per RFC 6368 if it exists, otherwise, the function uses the VPN path attributes.

The VPN_FUNCTION_NAME() function applies to the VPN route imported using the provider attributes. Modifications to path attributes in the VPN_FUNCTION_NAME() function don't apply to the provider path.

router bgp ASN
    [ vrf NAME ]
     route-target import ( vpn-ipv4 | vpn-ipv6 ) rcf IMPORT_FUNCTION_NAME()
     [ vpn-route filter-rcf VPN_FUNCTION_NAME() ]

router bgp 64500
  vrf VRF1
      route-target import vpn-ipv4 rcf IMPORT_POLICY() vpn-route 
      filter-rcf FILTER_VPN_ROUTES()

MPLS L3 VPN export

The EXPORT_FUNCTION_NAME() function applies to the unicast route created on export. The unicast route path attributes populate a BGP Customer Attribute Set if the iBGP as PE-CE Protocol fr BGP/MPLS L3 VPNS configured per RFC 6368, these attributes do not modify in the policy.

The VPN_FUNCTION_NAME() function applies to the VPN route exported. Modifications to path attributes in the VPN_FUNCTION_NAME() function apply to the provider path.

router bgp ASN
    [ vrf NAME ]
          route-target export ( vpn-ipv4 | vpn-ipv6 ) 
rcf EXPORT_FUNCTION_NAME()
          [ vpn-route filter-rcf VPN_FUNCTION_NAME() ]

router bgp 64500
  vrf VRF1
      route-target export vpn-ipv4 rcf EXPORT_POLICY() vpn-route 
filter-rcf FILTER_VPN_ROUTES()
      route-target export vpn-ipv6 rcf EXPORT_POLICY() vpn-route 
filter-rcf FILTER_VPN_ROUTES()

L3 EVPN import

The IMPORT_FUNCTION_NAME() function applies to the unicast route created on import.

router bgp ASN
   [ vrf NAME ]
       route-target import evpn rcf IMPORT_FUNCTION_NAME()

router bgp 64500
  vrf VRF1
      route-target import evpn rcf IMPORT_POLICY() 

L3 EVPN export

The EXPORT_FUNCTION_NAME() function applies to the EVPN route created on export.

router bgp ASN
   [ vrf NAME ]
         route-target export evpn rcf EXPORT_FUNCTION_NAME()

router bgp 64500
  vrf VRF1
      route-target export evpn rcf IMPORT_POLICY() 

EVPN VPWS Route Export

router bgp ASN
     vpws evpn instance
         route-target export evpn rcf FUNCTION_NAME()

router bgp 1
           vpws evi1
               route-target export evpn rcf EX PORT_POLICY() 

Aggregate-Address Configuration

The AGGREGATE_ATTRIBUTES_FUNCTION_NAME() function uses the generated aggregate route and the aggregate path attributes of the aggregate contributor roles as input to the function.

router bgp ASN
    aggregate-address prefix as-set attribute rcf
     AGGREGATE_ATTRIBUTES_FUNCTION_NAME()

router bgp 64500
    aggregate-address 192.0.2.0/24 attribute rcf AGGREGATE_FUNCTION()