Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/suquant/drone

Drone is a Continuous Integration platform built on Docker, written in Go
https://github.com/suquant/drone

Last synced: 5 months ago
JSON representation

Drone is a Continuous Integration platform built on Docker, written in Go

Awesome Lists containing this project

README 

          
Drone is a [Continuous Integration](http://en.wikipedia.org/wiki/Continuous_integration) platform built on [Docker](https://www.docker.io/)



[![Build Status](http://test.drone.io/v1/badge/github.com/suquant/drone/status.svg?branch=master)](http://test.drone.io/github.com/suquant/drone)

[![GoDoc](https://godoc.org/github.com/suquant/drone?status.png)](https://godoc.org/github.com/suquant/drone)



### Getting Started



* [Installation](http://drone.readthedocs.org/en/latest/install.html)

* [Configuration](http://drone.readthedocs.org/en/latest/setup.html)

* [Getting Help](http://drone.readthedocs.org/en/latest/index.html#need-help)



### Contributing



Interested in contributing? Great! Please read our [contributor guidelines](http://drone.readthedocs.org/en/latest/contribute.html#pull-requests).



---



* [System Requirements](#system)

* [Installation](#setup)

* [Builds](#builds)

* [Images](#images)

* [Application Environment](#environment)

* [Git Command Options](#git-command-options)

* [Deployments](#deployments)

* [Notifications](#notifications)

* [Database Services](#databases)

* [Caching](#caching)

* [Params Injection](#params-injection)

* [Wall display](#wall-display)

* [Local development](#local-development)

* [Documentation and References](#docs)



### System



Drone is tested on the following versions of Ubuntu:



* Ubuntu Precise 12.04 (LTS) (64-bit)

* Ubuntu Raring 13.04 (64 bit)



Drone's only external dependency is the latest version of Docker (0.8)



### Setup



Drone is packaged and distributed as a debian file. You can download an install

using the following commands:



```sh

$ wget http://downloads.drone.io/latest/drone.deb

$ sudo dpkg -i drone.deb

$ sudo start drone

```



Once Drone is running (by default on :80) navigate to **http://localhost:80/install**

and follow the steps in the setup wizard.



**IMPORTANT** You will also need a GitHub Client ID and Secret:



* Register a new application https://github.com/settings/applications

* Set the homepage URL to http://$YOUR_IP_ADDRESS/

* Set the callback URL to http://$YOUR_IP_ADDRESS/auth/login/github

* Copy the Client ID and Secret into the Drone admin console http://localhost:80/account/admin/settings



I'm working on a getting started video. Having issues with volume, but hopefully

you can still get a feel for the steps:



https://docs.google.com/file/d/0By8deR1ROz8memUxV0lTSGZPQUk



**Using MySQL**



By default, Drone use sqlite as its database storage. To use MySQL/MariaDB instead, use `-driver` flag

and set it to `mysql`. You will need to set your DSN (`-datasource`) in this form: 

```

    user:password@tcp(hostname:port)/dbname?parseTime=true

```

Change it according to your database settings. The parseTime above is required since drone using

`time.Time` to represents `TIMESTAMP` data. Please refer to [1] for more options on mysql driver.



You may also need to tweak some innodb options, especially if you're using `utf8mb4` collation type.

```

    innodb_file_format = Barracuda

    innodb_file_per_table = On

    innodb_large_prefix = On

```

Please consult to the MySQL/MariaDB documentation for further information

regarding large prefix for index column and dynamic row format (which is used in Drone).



[1] https://github.com/go-sql-driver/mysql



### Builds



Drone use a **.drone.yml** configuration file in the root of your

repository to run your build:



```

image: mischief/docker-golang

env:

  - GOPATH=/var/cache/drone

script:

  - go build

  - go test -v

services:

  - redis

notify:

  email:

    recipients:

      - brad@drone.io

      - burke@drone.io

```



### Images



In the above example we used a custom Docker image from index.docker.io **mischief/docker-golang**



Drone also provides official build images. These images are configured specifically for CI and

have many common software packages pre-installed (git, xvfb, firefox, libsqlite, etc).



Official Drone images are referenced in the **.drone.yml** by an alias:



```sh

image: go1.2   # same as bradrydzewski/go:1.2

```



Here is a list of our official images:



```sh

# these two are base images. all Drone images are built on top of these

# these are BIG (~3GB) so make sure you have a FAST internet connection

docker pull bradrydzewski/ubuntu

docker pull bradrydzewski/base



# clojure images

docker pull bradrydzewski/lein             # image: lein



# dart images

docker pull bradrydzewski/dart:stable      # image: dart



# erlang images

docker pull bradrydzewski/erlang:R16B      # image: erlangR16B

docker pull bradrydzewski/erlang:R16B02    # image: erlangR16B02

docker pull bradrydzewski/erlang:R16B01    # image: erlangR16B01



# gcc images (c/c++)

docker pull bradrydzewski/gcc:4.6          # image: gcc4.6

docker pull bradrydzewski/gcc:4.8          # image: gcc4.8



# go images

docker pull bradrydzewski/go:1.0           # image: go1

docker pull bradrydzewski/go:1.1           # image: go1.1

docker pull bradrydzewski/go:1.2           # image: go1.2

docker pull bradrydzewski/go:1.3           # image: go1.3



# haskell images

docker pull bradrydzewski/haskell:7.4      # image: haskell



# java and jdk images

docker pull bradrydzewski/java:openjdk6    # image: openjdk6

docker pull bradrydzewski/java:openjdk7    # image: openjdk7

docker pull bradrydzewski/java:oraclejdk7  # image: oraclejdk7

docker pull bradrydzewski/java:oraclejdk8  # image: oraclejdk8



# node images

docker pull bradrydzewski/node:0.10        # image node0.10

docker pull bradrydzewski/node:0.8         # image node0.8



# php images

docker pull bradrydzewski/php:5.5          # image: php5.5

docker pull bradrydzewski/php:5.4          # image: php5.4



# python images

docker pull bradrydzewski/python:2.7       # image: python2.7

docker pull bradrydzewski/python:3.2       # image: python3.2

docker pull bradrydzewski/python:3.3       # image: python3.3

docker pull bradrydzewski/python:pypy      # image: pypy



# ruby images

docker pull bradrydzewski/ruby:2.0.0       # image: ruby2.0.0

docker pull bradrydzewski/ruby:1.9.3       # image: ruby1.9.3



# scala images

docker pull bradrydzewski/scala:2.10.3     # image: scala2.10.3

docker pull bradrydzewski/scala:2.9.3      # image: scala2.9.3



```



### Environment



Drone clones your repository into a Docker container

at the following location:



```

/var/cache/drone/src/github.com/$owner/$name

```



Please take this into consideration when setting up your build commands, or

if you are using a custom Docker image.



### Git Command Options



You can specify the `--depth` option of the `git clone` command (default value is `50`):



```

git:

  depth: 1

```



### Deployments



Drone can trigger a deployment at the successful completion of your build:



```

deploy:

  heroku:

    app: safe-island-6261



publish:

  s3:

    acl: public-read

    region: us-east-1

    bucket: downloads.drone.io

    access_key: C24526974F365C3B

    secret_key: 2263c9751ed084a68df28fd2f658b127

    source: /tmp/drone.deb

    target: latest/



  swift:

    username: someuser

    password: 030e39a1278a18828389b194b93211aa

    auth_url: https://identity.api.rackspacecloud.com/v2.0

    region: DFW

    container: drone

    source: /tmp/drone.deb

    target: latest/drone.deb

    branch: master



```



Drone currently has these `deploy` and `publish` plugins implemented (more to come!):



**deploy**

- [heroku](#docs)

- [git](#docs)

- [modulus](#docs)

- [nodejitsu](#docs)

- [ssh](#docs)

- [tsuru](#docs)

- [bash](#docs)



**publish**

- [Amazon s3](#docs)

- [OpenStack Swift](#docs)

- [PyPI](#docs)



Publish plugins can be limited to a specific branch using the `branch` configuration

as seen above in the `swift` example. If you do not specify a `branch` all branches

will be published, with the exception of Pull Requests.



### Notifications



Drone can trigger email, hipchat and web hook notification at the beginning and

completion of your build:



```

notify:

  email:

    recipients:

      - brad@drone.io

      - burke@drone.io



  webhook:

    on_success: true

    on_failure: true

    urls:

      - http://my-deploy-hook.com



  hipchat:

    room: support

    token: 3028700e5466d375

    on_started: true

    on_success: true

    on_failure: true

```



### Databases



Drone can launch database containers for your build:



```

services:

  - cassandra

  - couchdb

  - couchdb:1.0

  - couchdb:1.4

  - couchdb:1.5

  - elasticsearch

  - elasticsearch:0.20

  - elasticsearch:0.90

  - neo4j

  - neo4j:1.9

  - mongodb

  - mongodb:2.2

  - mongodb:2.4

  - mysql

  - mysql:5.5

  - postgres

  - postgres:9.1

  - rabbitmq

  - rabbitmq:3.2

  - redis

  - riak

  - zookeeper

```



If you omit the version, Drone will launch the latest version of the database. (For example, if you set `mongodb`, Drone will launch MongoDB 2.4.)



You can also launch custom Docker containers using standard docker notation:



```sh

services:

  - dockerfile/rethinkdb # same as dockerfile/rethinkdb:latest

  - barnybug/elasticsearch:1.0.1

```



**NOTE 1:** database and service containers are exposed over TCP connections and

have their own local IP address. If the **socat** utility is installed inside your

Docker image, Drone will automatically proxy localhost connections to the correct

IP address.



**NOTE 2:** avoid running services that use the same ports. For example, don't specify

multiple versions of Elastic Search since the port will already be in use.



### Caching



Drone can persist directories between builds. This should be used for caching dependencies to

decrease overall build time. Examples include your `.npm`, `.m2`, `bundler`, etc.



```

cache:

  - /usr/local/bin/go/pkg

```



This will cache the directory relative to the root directory of your repository:



```

cache:

  - .npm

```



**NOTE:** this is an alpha quality feature and still has some quirks. See https://github.com/suquant/drone/issues/147



### Params Injection



You can inject params into .drone.yml.



```

notify:

  hipchat:

    room: {{hipchatRoom}}

    token: {{hipchatToken}}

    on_started: true

    on_success: true

    on_failure: true

```



![params-injection](https://f.cloud.github.com/assets/1583973/2161187/2905077e-94c3-11e3-8499-a3844682c8af.png)



### Wall display



A wall display for Drone is available as a separate service. See [Drone Wall](https://github.com/suquant/drone-wall)

for details.



### Local development



Local Drone setup for development is pretty straightforward.



You will need to clone the repo, install Vagrant and run `vagrant up`.

This command will download base Ubuntu image, setup the virtual machine and build Drone.



Afterwards, you may `vagrant ssh` into the vagrant instance, where docker is already installed and ready to go.



Once in the vagrant instance, run `make run`, the visit http://localhost:8080/install in your browser.



The Makefile has other targets so check that out for more build, test, run configurations.



### Docs



* [drone.readthedocs.org](http://drone.readthedocs.org/) (Coming Soon)

* [GoDoc](http://godoc.org/github.com/suquant/drone)