libslax Default Extension Libraries: bit, curl, db, os, and xutil

bit:and(b1, b2)

Return the logical AND of two bit strings.

bit:and("101100", "100101")return value: "100100"

bit:clear(b1,bitnum)

Set the specified bit in the bit string to zero and return the new bit string. Bits are numbered starting from zero. If the integer argument is greater than the bit string length, the bit string is extended.

bit:clear("11111", 0)return value: "11110"

bit:clear("11111", 6)return value: "0011111"

bit:compare(value1, value2)

Compare two values and return an integer less than, equal to, or greater than zero, if the first argument is found to be less than, equal to, or greater than the second argument, respectively.

bit:compare("10000", 16)return value: 0

bit:compare("11111", "10000")return value: 1

bit:from-hex(string, len?)

Return the value of the hexademical argument as a bit string. The optional second argument pads the bit string with leading zeros (0s) until it is the specified length.

bit:from-hex("0x45", 8)return value: "01000101"

bit:from-int(integer, len?)

Return the value of the integer argument as a bit string. The optional second argument pads the bit string with leading zeros until it is the specified length.

bit:from-int(65,8)return value: "01000001"

bit:mask(count, len?)

Return a bit string with the specified number of low-order bits set to one. The optional second argument pads the bit string with leading zeros until it is the specified length.

bit:mask(4, 8)return value: "00001111"

bit:nand(b1, b2)

Return the logical NAND of two bit strings.

bit:nand("101100", "100101")return value: "010010"

bit:nor(b1, b2)

Return the logical NOR of two bit strings.

bit:nor("101100", "100101")return value: "011011"

bit:not(b1)

Return the inversion (NOT) of a bit string.

bit:not("101100")return value: "010011"

bit:or(b1, b2)

Return the logical OR of two bit strings.

bit:or("101100", "100101")return value: "101101"

bit:set(b1, bitnum)

Set the specified bit in the bit string and return the new bit string. Bits are numbered starting from zero. If the integer argument is greater than the bit string length, the bit string is extended.

bit:set("1001", 2) return value: "1101"

bit:set("1001", 6) return value: "1001001"

bit:to-int(b1)

Return the value of the bit string argument as an integer.

bit:to-int("101100")return value: 44

bit:to-hex(b1)

Return the value of the bit string argument as a string representation of the hexadecimal value.

bit:to-hex("101100")return value: "0x2c"

bit:xor(b1, b2)

Return the logical XOR of two bit strings.

bit:xor("101100", "100101")return value: "001001"

bit:xnor(b1, b2)

Return the logical XNOR of two bit strings.

bit:xnor("101100",  "100101")return value: "110110"

db:close()

Close the database connection and free all the structures associated with previous operations performed on this handle.

db:create()

Create a collection in the database associated with the open database handle using the given field information.

db:delete()

Delete instances in a collection that match the given conditions in the database associated with the open database handle.

db:fetch()

Fetch a result instance using the cursor returned from a db:find() or db:query call.

db:find()

Return a cursor to the result set for instances matching the given conditions. db:fetch() must be used to retrieve each of the result instances.

db:find-and-fetch()

Find and read all the instances matching the given conditions.

db:insert()

Insert data into a collection in the database associated with the open database handle.

db:open()

Open a database connection using the provided options, which include the back-end database engine and the database name.

db:query()

Run a custom query.

db:update()

Update a set of instances matching the given conditions with the provided instance.

<collection>

Specify the data collection on which to perform operations. This corresponds to a SQL database table.

<collection> "employee";

<condition>

Specify a condition that must be satisfied when operating with data instances from the datastore. This forms the condition used with the WHERE clause when operating with a SQL datastore. Mandatory elements include:

• <selector>—Name of the field to which this condition applies

• <operator>–Comparison or logical operator (<, >, <=, >=, =, LIKE, IN, NOT)

• <value>—Value used with the operator on this field

<condition> {
    <selector> "id;
    <operator> "in";
    <value> "(1, 10)";
}

<conditions>

Specify multiple conditions with <and> or <or> as parent nodes.

<conditions> {
    <and> {
        <condition> {
            ... /* c1 */
        } 
        <condition> {
            ... /* c2 */
        } 
        <or> {
            <condition> {
                ... /* c3 */
            }
            <condition> {
                ... /* c4 */
            }
        }
    }
}

<database>

Specify the name of the database on which to operate.

<database> "test.db";

<engine>

Specify the back-end database engine that is used to store and access data.

<engine> "sqlite";

<field>

Define the metadata for each field in the collection.

<field> {
    <name> "name";
    <type> "integer";
    <primary>;        
}

<fields>

Specify metadata about fields in a collection using <field> child elements.

<fields> {
    <field> {
        ...
    }
}

<instance>

Represent a single instance in a collection when inserting or manipulating data in the datastore. The element contains fields and their corresponding values in that record.

<instance> {
    <id> 5;
    <name> "John";
}

<instances>

Define multiple instances in a collection when inserting or manipulating data in the datastore.

<instances> {
    <instance> {
        ...
        ...
    }
    ...
}

<limit>

Limit the number of instances that a result can contain.

<limit> 10;

<result>

Output node returned from most of the db extension functions. This node contains a <status> element and can contain one or more <instance> elements.

<result> {
    <status> {
        <ok>
    }
}

<retrieve>

Specify only the fields that should appear as part of the result set when querying the datastore.

<retrieve> {
    <id>;
    <name>;
}

<skip>

Skip over a specified number of instances in the result set before returning to the user.

<skip> 5;

<sort>

Specify the fields and the order by which the result set must be sorted.

Specify the fields by including the <by> element, and specify the sort order by setting the value of <order> to "asc" (ascending) or "desc" (descending).

<sort> {
    <by> "id";
    <by> "age";
    <order> "desc";
}

os:chmod

Change the permissions of one or more files.

17.4

os:chown

Change the file owner and group for one or more files.

17.4

os:exit-code

Set the exit code for the process running the script.

14.1

os:mkdir

Create a new directory with the specified name, path, and permissions.

The <create> option, which returns an error if the last element of the path exists, is supported starting in Junos OS Release 17.4R1.

14.1

os:remove

Delete a file or empty directory.

17.4

os:stat

Return information about files and directories in a node-set of <entry> elements, which contain details about each file.

14.1

os:user-info

Return a <user-info> element with information about the user running the script.

17.4

xutil:json-to-xml(string)

Convert a string containing JSON data into the native representation of that data in XML.

14.2

xutil:max-call-depth(number)

Limit the depth of recursive calls. The default limit is 3000.

14.1

xutil:string-to-xml(string+)

Convert a string containing XML data into the native representation of that data.

12.2

xutil:xml-to-json(node-set+)

Convert XML data into a string containing JSON data. This function encodes tags as JSON objects inside a string.

14.2

xutil:xml-to-string(node-set+)

Convert XML data into a string.

12.2