bundle agent main
{
  files:
      "/etc/nologin"
        handle => "touch_etc_nologin",
        comment => "Quiesce the system for maintenance",
        create  => "true";
}

bundle agent main
{
  files:

      "/var/cfengine/i_am_alive"

        comment => "Update heartbeat timestamp (mtime)
                          to confirm CFEngine is running",
        create  => "true",
        touch   => "true";
}

bundle agent main
{
  commands:
      "/bin/date"
        comment => "Demonstrate a simple commands promise";
}

bundle agent main
{
  commands:
      "/bin/echo Hello, World!"
        comment => "Demonstrate a command with arguments (in promiser)";
}

bundle agent main
{
  commands:
      "/bin/echo"
        comment => "Sometimes it is convenient to separate command
                    and arguments.",
        args => "Hello, World!";
}

# Reference:
# https://docs.cfengine.com/latest/reference-promise-types-commands.html#args

bundle agent main
{
  commands:
      "echo"
        args => "Hello world",
        comment => "Relative path does not work.";
}

#!/bin/sh

# Demonstrate how CFEngine truncates names of long
# commands.
#
# Create an executable with a long path name - we'll need
# it for the next example.

LONG_PATH=/usr/local/sbin/a/really/long/path/to
sudo /bin/mkdir  -p ${LONG_PATH}
sudo /bin/cp -p /bin/echo ${LONG_PATH} >/dev/null
sudo ls -l /bin/echo ${LONG_PATH}/echo

# demonstrate handling of long command names in agent output

bundle agent main
{
  commands:
      "/usr/local/sbin/a/really/long/path/to/echo"
        args => "Hello, World!";
}

# demonstrate handling of multi-line output

bundle agent main
{
  commands:
      "/usr/bin/printf"
        args => "%s\n%s\n%s\n One Two Three",
        comment => "Produce a multi-line command output";
}

bundle agent main
{
  reports:

      "Hello, World!";
}

bundle agent main {

  methods:
      "any"
         usebundle => say_hello;

}

bundle agent say_hello {

reports:  "hello!";

}

#!/bin/sh

set -x  # show us each command after expanding it,
        # so we can see what commands are being run

# Add a couple of users and a crontab to set up for the next example

sudo useradd alex
sudo useradd rob

# Create a crontab for user "alex"
EDITOR="/bin/echo @daily /bin/echo hello world > " sudo crontab -e -u alex

sudo crontab -l -u alex

# Example of parameterizing a methods promise
# pass a list, not a scalar
bundle agent main
{
  vars:
      "userlist" slist => { "alex", "ben", "charlie", "diana", "rob" };

  methods:
      "Remove Users"
        usebundle => remove_users(@(userlist));
}

bundle agent remove_users(users_to_remove)
{
  reports:  
      "Checking $(users_to_remove)";

  commands:

    linux::
      "/bin/crontab -r -u $(users_to_remove)"
        if => fileexists("/var/spool/cron/$(users_to_remove)");
      "/usr/sbin/userdel -r $(users_to_remove)"
        if => userexists("$(users_to_remove)");
}

# Example of parameterizing a methods promise
# pass a list, not a scalar
bundle agent main
{
  vars:
      "userlist" slist => { "alex", "ben", "charlie", "diana", "rob" };

  methods:
      "Remove Users"
        usebundle => remove_users(@(userlist));
}

bundle agent remove_users(userlist)
{
  commands:
    linux::
      "/bin/crontab -r -u $(userlist)"
        if => fileexists("/var/spool/cron/$(userlist)");
      "/usr/sbin/userdel -r $(userlist)"
        if => userexists("$(userlist)");
}

# Example of parameterizing a methods promise

bundle agent main
{
  vars:
      "userlist" slist => { "alex", "ben", "charlie", "diana", "rob" };

  methods:
      "Remove Users"
        usebundle => remove_user("$(userlist)");
}

bundle agent remove_user(user)
{
  commands:
      "/bin/crontab -r -u $(user)"
        if => fileexists("/var/spool/cron/$(user)");
      "/usr/sbin/userdel -r $(user)"
        if => userexists("$(user)");
}

bundle agent main
{
  classes:
      "weekend"
        expression => "Saturday|Sunday";
      "weekday"
        expression => "Monday|Tuesday|Wednesday|Thursday|Friday";

  reports:
    weekend::
      "Yay! I get to rest today.";
    weekday::
      "Yay! I get to work today.";
}

# Example of "negative knowledge" -- not recommended!
# Better to be certain (rely on the presence of something,
# not its absence).

bundle agent main
{
  classes:
      "weekend"
        expression => "Saturday|Sunday";
      "weekday"
        not => "weekend";

  reports:
    weekend::
      "Yay! I get to rest today.";
    weekday::
      "Yay! I get to work today.";
}

# Knowing that something is not the case is not the same as not knowing
# whether something is the case. That a class is not set could mean
# either.
#
# Reference:  <https://docs.cfengine.com/docs/3.17/reference-language-concepts-classes.html#negative-knowledge>

# You can set a soft class based on the outcome
# of a function that returns true/false, such as
# `regline()` which checks if there is a line in a
# file matching a regular expression.

bundle agent main
{
  classes:
      "i_am_virtual"
        comment => "Check if we are running inside a VM",
        expression => regline(".*(VMware|VBOX|QEMU).*",
                              "/proc/scsi/scsi");

# E.g., on a VMware guest, we have:
#
# $ grep -i vmware /proc/scsi/scsi
# Vendor: VMware,  Model: VMware Virtual S Rev: 1.0
# Vendor: NECVMWar Model: VMware SATA CD01 Rev: 1.00
# $

  reports:
    i_am_virtual::
      "Running inside a VM";
}

# See also the "virt-what" utility

# Example of multiple promises in one bundle

bundle agent main
{
  files:
      "/tmp/hello"
        create  => "true";

  files:
      "/tmp/world"
        create  => "true";
}

# Example of two bundles in one file
#
# $(this.bundle) is a special variable that contains the name of the
# current bundle.
#
# A `methods:` promise is a promise to take on a whole another bundle of
# promises.

bundle agent main
{
  methods:
      "bundle_2";

  reports:
      "I am in the $(this.bundle) bundle";
}

bundle agent bundle_2
{
  reports:
      "I am in the $(this.bundle) bundle";
}

# Whitespace/indentation does not matter, these bundles will both work

bundle agent with_whitespace
{
  files:
      "/etc/nologin"
        create => "true";
}

bundle agent no_whitespace { files: "/etc/nologin" create => "true"; }

bundle agent main
{
  files:

      "/tmp/hello"
        create  => "true";

      "/tmp/world"
        create  => "true";
}

bundle agent main
{
  files:
      "/tmp/hello"
        create  => "true",
        comment => "inline-comments show up in verbose mode";
      # hash-comments are thrown away by parser
}

# Demonstrate three passes through a bundle by using verbose mode

bundle agent main
{
  files:
      "/tmp/example"
        handle => "create_a_file",
        create  => "true";
}

# Example of a promise handle

bundle agent main
{
  files:
      "/tmp/testfile"
        handle => "create_testfile", # <-- promise handle 
        create => "true";
}

# Promise handles MUST be unique.
#
# The following is NOT valid CFEngine.

bundle agent main
{
  files:
      "/tmp/testfile"
        handle => "create_testfile",
        create  => "true";

  reports:
     "hello world"
       handle => "create_testfile";
}

bundle agent main
{
  reports:

      "Launch!!"
        depends_on => { "fuel" },  # <-- dependencies
        handle => "launch";

      "Fueling"
        handle => "fuel";
}

# Documenting the Stakeholders

bundle agent main
{

  files:
      "/etc/httpd/conf/httpd.conf" -> { "Web Services team", "NOC" }
        create  => "true";
}

# Documenting what depends on this promise

bundle agent main
{
  reports:

      "Launch!!"
        depends_on => { "fuel" },
        handle => "launch";

      "Fueling" -> { "launch" }   # <-- promisee
        handle => "fuel";
}

# You can have multiple dependencies

bundle agent main
{
  reports:

      "Launch!!"
        depends_on => { "systems_check", "fuel" },
        handle => "ignition";

      "Systems Check"
        handle => "systems_check";

      "Fueling..."
        handle => "fuel";

}

# You can have multiple promisees

bundle agent main
{
  reports:

      "Systems Check" -> { "fuel", "launch" }
        handle => "systems_check";
}

# run this in verbose mode and notice the comment

bundle agent main
{
  files:
      "/tmp/testfile"
        comment => "Create a vital file, needed for XYZ.",
        create  => "true";
}

# Demonstrate by running this with DEBUG and then with DEBUG_main and
# DEBUG_prep classes to control debug reporting
#
# cf-agent -D DEBUG -f <thisfile>
# cf-agent -K -D DEBUG_main -f <thisfile>
# cf-agent -K -D DEBUG_prep -f <thisfile>

bundle agent main {

  vars:
    "name"
      string => "George";

  methods:
    "prep";

  reports:
    DEBUG|DEBUG_main::
      "DEBUG $(this.bundle)";
      "$(const.t)DEBUG $(this.bundle): name = '$(name)'";
}

bundle agent prep {

reports:
  DEBUG|DEBUG_prep::
      "DEBUG $(this.bundle)";
      "$(const.t)DEBUG $(this.bundle): foo = 'bar'";
}

# Create a file and populate its content

bundle agent main
{
  files:
      "/etc/motd"
        create  => "true",
        edit_line => greet_users;
}

bundle edit_line greet_users
{
  insert_lines:
      "Good morning!";
}

# You can parameterize bundles -- let's try that with
# the edit_line bundle

bundle agent main
{
  files:
      "/etc/motd"
        create  => "true",
        edit_line => say_something("Good morning");
}

bundle edit_line say_something(what_we_say)
{
  insert_lines:
      "$(what_we_say)";
}

# Change "good morning" to "good afternoon".
# What will the file contain after we run cf-agent?

bundle agent main
{
  files:
      "/etc/motd"
        create  => "true",
        edit_line => greet_users;
}

bundle edit_line greet_users
{
  insert_lines:
      "Good afternoon!";
}

# You can control the entire file content by adding
# the edit_line promise `delete_lines: "*";`

bundle agent main
{
  files:
      "/etc/motd"
        create => "true",
        edit_line => my_motd;
}

bundle edit_line my_motd
{
  insert_lines:
      "Good afternoon!";

  delete_lines:
      ".*";
}

# Why doesn't this just leave the file empty?

# You can insert a file using the `insert_type`
# attribute of `insert_lines` promises.

bundle agent main
{
  files:
      "/tmp/test.txt"
        create => "true",
        edit_line => mytext;
}

bundle edit_line mytext
{
  insert_lines:
      "Here are our OS details";
      "/etc/os-release"
        insert_type => "file";
}

bundle agent main
{
  files:
      "/tmp/test.xml"
        comment => "Create XML file",
        create => "true",
        edit_xml => build_xpath;
}

bundle edit_xml build_xpath
{
   build_xpath:
      "/Server/Service/Engine";

}

bundle agent main
{
  files:
      "/tmp/test.xml"
        edit_xml => my_xml_example;
}

bundle edit_xml my_xml_example
{
  insert_tree:
      '<Host name="a014848585.example.com">
             <Alias>mail.example.com</Alias>
       </Host>'
        select_xpath => "/Server/Service/Engine";
}

bundle agent main
{
  files:
      "/tmp/test.xml"
        edit_xml => set_value;
}

bundle edit_xml set_value
{
  set_text:
      "nancy.example.com"
        select_xpath => "/Server/Service/Engine/Host/Alias";

}

body <type> name
{
  attribute1 => value1;
  attribute2 => value2;
  ...
  attributeN => valueN;
}

# run "groupadd project_team" to create the group
# "project_team" for this example

bundle agent main
{
  files:

      "/tmp/file1"
        create => "true",
        perms   => project_files;

      "/tmp/file2"
        create => "true",
        perms   => project_files;
}

body perms project_files
{
        mode   => "770";
        owners => { "root" };
        groups => { "project_team" };
}

# You can use class expressions in body parts

bundle agent main
{
  files:
    any::
      "/tmp/testfile"
        comment  => "Set appropriate file attributes for Admin group
                     on every type of OS",
        create  => "true",
        perms   => admin_group;
}

body perms admin_group
{
  linux::  groups => { "wheel" };
  darwin:: groups => { "admin" };
  sunos::  groups => { "sys" };

}

# You can parameterize body parts

bundle agent main
{
  files:

      "/tmp/testfile"
        create  => "true",
        perms   => set_mode_700_admin_group_and_specified_user("sam");
}

body perms set_mode_700_admin_group_and_specified_user(user)
{
        mode   => "0700";
        owners => { "$(user)" };

      linux::  groups => { "wheel" };
      darwin:: groups => { "admin" };
      sunos::  groups => { "sys" };
}

# Run "echo I am going to walk my dog > /tmp/data.txt" to set up for
# this example

# Demonstrate search-and-replace in a file

bundle agent main
{
  files:
    any::
      "/tmp/data.txt"
        edit_line => transform_dogs_to_cats;
}

bundle edit_line transform_dogs_to_cats
{
  replace_patterns:
      "[Dd]og"
        replace_with => value("cat");
}

body replace_with value(x)
{
        replace_value => "$(x)";
        occurrences => "all";
}

# files: perms takes a list of okay groups
# Change to first entry if not matching any of the groups in the list
#
# Run "sudo touch /tmp/testfile; sudo chmod 777 /tmp/testfile; sudo chgrp nobody /tmp/testfile"
# to set up for this example.

bundle agent main
{
  files:
      "/tmp/testfile"
        perms => not_world_writable_and_right_group;
}

body perms not_world_writable_and_right_group
{
        groups => {"root", "games", "mail" };
        mode   => "o-w";
}

# A body part can be re-used across promises
#
# run "useradd bob; useradd susan" to set up for this example

bundle agent main
{
  files:
      "/tmp/bobsfile"
        create  => "true",
        perms   => mog("777", "bob", "mail");

      "/tmp/susansfile"
        create  => "true",
        perms   => mog("000", "susan", "games");
}

body perms mog(mode,owner,group)
{
  mode    => "$(mode)";
  owners  =>  {"$(owner)"};
  groups  =>  {"$(group)"};
}

# Example of
#     cfengine_word => builtin_function()

bundle agent main
{
  vars:
      "formatted"
        string => format("%04d", 1);

  reports:
      "$(formatted)";
}

# Example of
#
#      cfengine_word => { list }    #  (directly and via list variable)

bundle agent main
{
  vars:
      "my_slist_0"
        slist  => {
                    "String contents...",
                    "... are beauutifuuul this time of year"
                  };

      "my_slist_1"
        slist  => { @(my_slist_0), "apple", "orange" };
}

bundle agent main {

  files:

      "/tmp/testfile"
        comment => "Demonstrate setting file attributes",
        create  => "true",
        perms   => mog("612","aleksey","cfengine");

}

############################################################

body perms mog(mode,owner,group)
{
        owners => { "$(owner)", "john", "brian" };
        mode   => "$(mode)";
        groups => { "$(group)" };
}

body file control
{
  inputs => { "$(sys.libdir)/stdlib.cf" };  # <-- read in the library
}

bundle agent main
{
  reports:
      "CFEngine StdLib is here: $(sys.libdir)/stdlib.cf" ; 

  files:
      "/tmp/testfile"
        create  => "true",
        perms   => mog("612","root","nobody");
}

bundle agent main
{
  files:
      "/etc/shadow"
        handle => "context_sensitive_file_editing_demo",
        comment => "demonstrate context-sensitive file editing capability",
        edit_line => set_user_field("rob",
                                    "2",
                                    "$1$stIAaUZw$ptP75nVkz/EapeuvdWLNC0");
}

body file control { inputs => { "$(sys.libdir)/stdlib.cf" }; }

bundle agent main
{
  files:
      "/tmp/testfile.*"
        handle => "demo_removing_files",
        comment => "Demonstrate removing files using body delete tidy",
        delete => tidy;

      # shell equivalent:  rm -r /tmp/testfile*

}

body file control { inputs => { "$(sys.libdir)/stdlib.cf" }; }

bundle agent main
{
  files:
      "/etc/httpd/conf.d/maintenance.conf"
        handle    => "take_website_out_of_maintenance",
        comment   => "Disable maintenance-mode config block",
        edit_line => comment_out_everything;
}

bundle edit_line comment_out_everything
{
  replace_patterns:
      "^([^#].*)"
        replace_with => comment("# ");
}

body replace_with comment(c)
{
        replace_value => "$(c) $(match.1)";
        occurrences => "all";
}

bundle agent main
{
  files:
      "/etc/httpd/conf.d/maintenance.conf"
        handle    => "put_website_into_maintenance",
        comment   => "Enable maintenance-mode config block",
        edit_line => uncomment_everything;
}

bundle edit_line uncomment_everything {
  replace_patterns:
      "^#(.*)"
        handle => "uncomment_everything_replace_pattern",
        comment => "If it starts with a hash mark, grab everything
                          after the hash mark, and uncomment it.",
        replace_with => uncomment;
}


body replace_with uncomment
{
        replace_value => "$(match.1)";
        occurrences => "all";
}

bundle agent main
{
  files:
      "/etc/httpd/conf.d/welcome.conf"
        handle => "nuke_welcome_conf",
        comment => "Let's keep a low profile and not advertise
                          what software we are running - remove the
                          Welcome page that says we are running Apache
                          on CentOS",
        delete => tidy;
}

body file control { inputs => { "$(sys.libdir)/stdlib.cf" }; }