rcm

1) # Notes on tool's architecture
2) 
3) This is Rudimentary Configuration Management (RCM) tool and is super true to its name. Everything is under `RCM` module/namespace to differentiate with other gems/ruby classes on the system.
4) 
5) Things are dependent on order of execution; especially if a resource is created by another one in the run. In our case, this is experienced for managing `/var/www/html/index.html` file as it is created by installation of `apache2`.
6) 
7) ## Target system configuration
8) 
9) `apache2`, `php5`  and `libapache2-mod-php5` are installed. Then default `/var/www/html/index.html` is deleted and `/var/www/html/index.php` is dropped in its place.
10) 

11) ## Installation and invocation
12) 
13)     wget http://src.devghai.com/rcm/tarball/master -O rcm.tar
14)     mkdir rcm
15)     tar --directory rcm -xzf rcm.tar
16)     cd rcm
17)     sudo ./bootstrap.sh

18)     sudo ./task.rb
19) 

20) 

21) ## Structure
22) 

23) The layout of the project is as simple as it can be. All objects are in `objects` folder, while all the functions that execute on those objects, or their collection are in respective file in `managers` folder. `task.rb` is the controller. Configuration is parsed in `managers/rcm_config_manager.rb`.

24) 
25) ### Configration and resources
26) 
27) YAML parser is natively available in ruby core, and was chosen over JSON for its easier markup. There are only in 3 sections in `config.yaml` - `packages`, `files` and `services` - and they are processed in that order. Files needed by the program (`hello_world.php`) are in `resources` folder. Dependencies can be specified for services, with a condition that `path` for file and `name` for package need to appear in respective section. There is no way to specify dependency for package or file at this time.
28) 
29) ### Objects
30) 

31) All objects are under `objects` folder. `rcm_file`, `rcm_package` and `rcm_service` provide abstraction of respective resource for RCM purposes. They hold everything needed to evaluate current vs desired state.

32) 
33) ### Managers
34) 

35) All functions that can be performed on an object or their collection are held in `managers` folder.

36) 
37) For file operations, I rely on `FileUtils` provided by ruby core, whereas I execute commands on systems for packages. Had I used Python, there was an API available to interact with package system. After all, apt is also a Python application.
38) 
39) ## How's the tool working
40) 
41) `bootstrap.sh` ensures `ruby2.0` is installed.
42) 
43) `task.rb` is the main file and contains `main`. `config_<env>.yaml` holds environment dependent configuration. If `ENVIRONMENT` is not set, `config.yaml` is loaded, otherwise program expects environment dependent configuration as mentioned above.
44) 
45) Config file is loaded at startup and various checks done to make sure configuration is is correct... within the bounds of this task. For example, for file resource `desired_state` is checked to be one of available types; and it is made sure that `local_file` is readable _if_ state is set to present. If there are dependencies mentioned for a service, a pointer to the resource is held respectively in `depends_file` and `depends_package` in `::RCM::Package` object.
46) 

47) `@wanted` holds the state as mentioned in `config.yaml` or `config_<env>.yaml`. It is populated in `::RCM::ConfigManager` during initialization.