April 20, 2012
I’ve mentioned mockchain a few times here. An interaction with averi today on irc pointed out that I should give some examples of how to use it.
Use case #1:
I have a big pile of srpms – I’m pretty sure they all build, but not sure in what order, I want them all built against fedora-16-x86_64.
mockchain fedora-16-x86_64 -l /tmp/myrepo –recurse *.src.rpm
That will produce a dir at /tmp/myrepo which has a config and results dir filled with: resulting pkgs and the logs from the build process in a subdir per package.
Inside the results dir there will be a fedora-16-x86_64 dir which is a yum repository and can be referred to in a yum repo configuration like:
name= my repo I just built with mockchain
It will also try to build each and every package and any failures will be tried again after everything else has been built – and this will continue in a loop until either all the packages are successfully built or the failures are identical on two loops.
Use Case #2:
I have a bunch of src.rpms, I want to build them, one at a time. After each package build I want to rsync my packages up to fedorapeople immediately for everyone to use.
for pkg in ~/pkgs/*.src.rpm
mockchain fedora-16-x86_64 -l /tmp/myrepo $pkg
rsync -avH -e ssh /tmp/myrepo/results/ fedorapeople.org:public_html/myrepo
Use Case #3:
I have some new pkgs I want to build for fedora-16-x86_64. I have a remote repository that contains additional pkgs which provide some of my build dependencies for these new pkgs.
mockchain fedora-16-x86_64 -a http://servername/path/to/my/remote/repo -l /tmp/myrepo -c *.src.rpm
This will give you a repo in /tmp/myrepo/results/fedora-16-x86_64
Just a few examples of how you can use mockchain in your daily operations.
April 19, 2012
On a suggestion from kevin – I added a –recurse option to mockchain. It builds all the pkgs it can and records the failures. When it gets to the end of the stack it tries to build the failures again and keeps trying until either: everything succeeds or the set of failures is the same – twice in a row.
Works pretty well to build a giant pile of pkgs and walk away.
I also talked to clark about mockchain and mock and he’s going to pull it in as a script in mock itself once I get it ready.
Here’s the latest version of things:
Try it out and let me know what it needs.
April 15, 2012
-a url - add this repo url to the yumconfig for the buildroot. This can be specified multiple times. Let's you point to multiple paths beyond the default to pull build deps from.
April 13, 2012
Talking to halfline today and yesterday I decided to spend a little time playing with this for another project.
mockchain.py [options] chrootname file.src.rpm [file1.src.rpm] [file2.src.rpm] ... Builds a series of srpms in mock one at a time. After each successful build of a package it adds the resulting packages to a local repo which are available to the next package to satisfy buildreqs. options: -c - continue on package build failure - by default it will exit if a package fails to build. set this if you wish it to try and continue for the rest of the packages. -l path - set the path to put the results/repo in. This path needs to be somewhere accessible to users other than you for reading as the mock process doesn't run as you. This does not try to sort the packages by build order b/c that is too much effort and not obviously doable with the buildreq information we have. The build process when you use -l is idempotent so a package which has already been successfully built will not be built again. If you want to force the rebuild of a package which has been built successfully simply remove the 'success' file from the dir with the package results in it.
April 11, 2012
Talking on irc tonight pointed out a lacking in the docs of ansible. Specifically, explaining the dirt-simple nature of how it works.
0. ansible has modules – modules are just executable code/scripts in any language you want – there are only 2 requirements:
a. that whatever language you want to write them in is available on the remote system(s)
b. that the modules return json as their results.
1. ansible connects to a host(or many hosts) using ssh
2. ansible shoves across the module(s) you want to run
3. ansible shoves across the arguments you want to pass to the module(s)
4. ansible runs the modules with the arguments
5. ansible gets back json from the modules and sends it to the calling script/program to be handled and/or displayed.
Now – for a lot of people the only module they really care about it is the ‘command’ or ‘shell’ module – which just lets you run a command directly on the system and it returns the results to the calling program. Pretty handy for any number of things. However, you can write a custom module – which is really nothing more than a script that ansible runs remotely. Ansible just handles the communication/execution part to multiple systems at the same time and return the results back to you, sensibly.
So that’s the dead-simple version of what ansible can do.
How do you as an admin wanting to test it out get started?
git clone https://github.com/ansible/ansible.git
echo “somehost-i-have-root-on” > ~/ansible-hosts
If you have a root ssh key setup then you can run:
bin/ansible all -i ~/ansible-hosts “uptime”
if you don’t have a root ssh key setup then run:
bin/ansible all -k -i ~/ansible-hosts “uptime”
it will prompt you for the root password
Add more hosts to ~/ansible-hosts to talk to more at the same time.
April 11, 2012
I’ve been working with/on ansible off and on for a couple of weeks now. I’ve got a simple reinstall playbook created and the basics of how we create new builders.
I was also working on using ansible as an api to port over some tools from func. After getting a bit sidetracked getting it to have a optparser function so I didn’t have to duplicate all those options in ever script I ported the func-host-reboot script over and improved it a bit:
The advantage of using the python interface is I don’t have to write things using the playbook language when I really want to do something more involved and I like the idea of being able to do multiple commands BETWEEN hosts and interplay their results.
I’m thinking that, coupled with kickstart, we should be able to streamline all of our provisioning. Additionally, I’m thinking that the api (esp for the playbooks) should let me play with more ad-hoc builder creation and package build submission.
I’m trying to figure out where this fits.
We have pieces that can do all of these things, mostly, but all of them require some other kind of setup to make work. I have 3 f16 hosts, 1 el6 box and 1 el5 box that I’m testing these against. I run against all of them at the same time and, other than sshd and python none of them have any specific installed on them for ansible to be able to run.
Is a lightweight “clientless” mgmt system a good idea? Is it enough of a feature to make it worth pursuing?
It feels like it helps overcome the pain-in-the-ass quality that is setting up most systems-mgmt infrastructure.