Initial commit.

Everything is done but the init-lxc function.

Author: ralt

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Florian Margaine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.txt

@@ -0,0 +1,53 @@
+# lxc-wrapper
+
+My personal LXC wrapper.
+
+## Motivation
+
+I use LXC in a very opinionated way, and has some manual maintenance
+to do every time I do something with LXCs. So I created this tool to
+automate what I do with them.
+
+## API
+
+### `create`
+
+```lisp
+(defun create (name &key base template)
+  "Creates an LXC"
+```
+
+Creates an LXC. If a base LXC is provided, then it makes a clone of
+it. If a template is provided, then it creates a new LXC based on this
+template.
+
+### `start`
+
+```lisp
+(defun start (name)
+  "Starts an LXC"
+```
+
+Starts an LXC. The argument can be a string or a symbol.
+
+### `stop`
+
+```lisp
+(defun stop (name)
+  "Stops an LXC"
+```
+
+Stops an LXC. The argument can be a string or a symbol.
+
+### `ls`
+
+```lisp
+(defun ls ()
+  "Lists all the LXC"
+```
+
+Returns the fancy output of the list of LXCs.
+
+## License
+
+MIT License.

lxc-wrapper.asd

@@ -0,0 +1,10 @@
+;;;; lxc-wrapper.asd
+
+(asdf:defsystem #:lxc-wrapper
+  :description "My personal LXC wrapper"
+  :author "Florian Margaine <florian@margaine.com>"
+  :license "MIT License"
+  :serial t
+  :depends-on ("external-program")
+  :components ((:file "package")
+               (:file "lxc-wrapper")))

lxc-wrapper.lisp

@@ -0,0 +1,77 @@
+;;;; lxc-wrapper.lisp
+
+(in-package #:lxc-wrapper)
+
+;;; "lxc-wrapper" goes here. Hacks and glory await!
+
+(defmacro run (&body command)
+  "Runs a command using sudo. LXC requires sudo.
+To avoid having an awkward API (i.e. passing a list),
+defining this as a macro."
+  (let ((stream (gensym)))
+    `(with-output-to-string (,stream)
+       (external-program:run
+	 "sudo"
+	 (list ,@command)
+	 :output ,stream
+	 :environment '(("$PATH" . "/usr/bin")))
+       ,stream)))
+
+(defun init-lxc (name)
+  "Initializes the LXC after creating it. It means:
+- Giving it a static IP
+- Adding the static IP to the host's /etc/hosts
+- Making a symlink to the rootfs somewhere")
+
+(defun create (name &key base template)
+  "Creates an LXC"
+  (if base
+      (create-clone base name)
+      (create-base name template)))
+
+(defun create-clone (base name)
+  "Creates a clone of another LXC"
+  (let ((cli-base (adapt-arg base))
+	(cli-name (adapt-arg name)))
+    (run
+      "lxc-clone"
+      "--orig" cli-base
+      "--new" cli-name)
+    (init-lxc cli-name)))
+
+(defun create-base (name template)
+  "Creates an LXC from no base"
+  (let ((cli-name (adapt-arg name))
+	(cli-template (adapt-arg template)))
+    (run
+      "lxc-create"
+      "--name" cli-name
+      "-t" cli-template)
+    (init-lxc cli-name)))
+
+(defun start (name)
+  "Starts an LXC"
+  (let ((cli-name (adapt-arg name)))
+    (run
+      "lxc-start"
+      "--name" cli-name)))
+
+(defun stop (name)
+  "Stops an LXC"
+  (let ((cli-name (adapt-arg name)))
+    (run
+      "lxc-stop"
+      "--name" cli-name)))
+
+(defun ls ()
+  "Lists all the LXC"
+  (run
+   "lxc-ls"
+   "--fancy"))
+
+(defun adapt-arg (name)
+  "Adapts an argument to string"
+  (when (symbolp name)
+    (string-downcase (symbol-name name)))
+  (when (stringp name)
+    (string-downcase name)))

package.lisp

@@ -0,0 +1,5 @@
+;;;; package.lisp
+
+(defpackage #:lxc-wrapper
+  (:use #:cl)
+  (:export :create :start :stop :ls))