README

Otto

Otto

Otto knows how to develop and deploy any application on any cloud platform, all controlled with a single consistent workflow to maximize the productivity of you and your team.

For more information, see the introduction section of the Otto website.

Key Features

The key features of Otto are:

  • Automatic development environments: Otto detects your application type and builds a development environment tailored specifically for that application, with zero or minimal configuration. If your application depends on other services (such as a database), it'll automatically configure and start those services in your development environment for you.

  • Built for Microservices: Otto understands dependencies and versioning and can automatically deploy and configure an application and all of its dependencies for any environment. An application only needs to tell Otto its immediate dependencies; dependencies of dependencies are automatically detected and configured.

  • Deployment: Otto knows how to deploy applications as well develop them. Whether your application is a modern microservice, a legacy monolith, or something in between, Otto can deploy your application to any environment.

  • Docker: Otto can use Docker to download and start dependencies for development to simplify microservices. Applications can be containerized automatically to make deployments easier without changing the developer workflow.

  • Production-hardened tooling: Otto uses production-hardened tooling to build development environments (Vagrant), launch servers (Terraform), configure services (Consul), and more. Otto builds on tools that powers the world's largest websites. Otto automatically installs and manages all of this tooling, so you don't have to.

Getting Started & Documentation

All documentation is available on the Otto website.

Developing Otto

If you wish to work on Otto itself or any of its built-in systems, you'll first need Go installed on your machine (version 1.4+ is required).

For local dev first make sure Go is properly installed, including setting up a GOPATH.

Next, clone this repository into $GOPATH/src/github.com/hashicorp/otto. Then use make to get the dependencies and run the tests. If this exits with exit status 0, then everything is working!

$ make updatedeps
...
$ make
...

To compile a development version of Otto, run make dev. This will put the Otto binary in the bin and $GOPATH/bin folders:

$ make dev
...
$ bin/otto
...

If you're developing a specific package, you can run tests for just that package by specifying the TEST variable. For example below, only otto package tests will be run.

$ make test TEST=./otto
...
Acceptance Tests

Otto also has a comprehensive acceptance test suite covering most of the major features of the built-in app types.

If you're working on a feature of an app type and want to verify it is functioning (as well as hasn't broken anything else), we recommend running the acceptance tests. Note that we do not require that you run or write acceptance tests to have a PR merged. The acceptance tests are here for your convenience, and we'll add them if they're missing.

Note: Acceptance tests are slow. They spin up real resources and take time to run. We recommend filtering as documented below to speed up your workflow.

To run the acceptance tests, invoke make testacc:

$ make testacc TEST=./builtin/app/go TESTARGS='-run=dev'
...

The TEST variable is required, and you should specify the folder where the app type is. The TESTARGS variable is recommended to filter down to a specific test to run, since running all of them at once can take a very long time.

Expand ▾ Collapse ▴

Documentation

The Go Gopher

There is no documentation for this package.

Directories

Path Synopsis
app app contains the interfaces and structures for application type implementations for Otto.
appfile
appfile/detect
appfile/detect/test-fixtures/app-go
appfile/load
builtin/app/custom
builtin/app/docker-external
builtin/app/go
builtin/app/go/test-fixtures/basic
builtin/app/java
builtin/app/node
builtin/app/php
builtin/app/python
builtin/app/ruby
builtin/app/scriptpack
builtin/foundation/consul
builtin/infra/aws
builtin/pluginmap pluginmap is a package that contains the mapping of internal plugin names to their factories that we can register it in various ways.
builtin/scriptpack/java
builtin/scriptpack/php
builtin/scriptpack/python
builtin/scriptpack/ruby
builtin/scriptpack/skeleton
builtin/scriptpack/stdlib
command
context
directory The directory package includes the interface for the Otto Appfile directory service that stores data related to Appfiles.
foundation
helper/bindata
helper/bindata/test-pkg
helper/compile
helper/exec
helper/flag
helper/hashitools
helper/localaddr localaddr is a helper library for allocating local IP addresses.
helper/oneline
helper/packer
helper/pongo2
helper/router
helper/schema
helper/semaphore
helper/sshagent Helpers for interacting with the local SSH Agent
helper/terraform
helper/uuid
helper/vagrant
infrastructure
otto
plugin The plugin package exposes functions and helpers for communicating to plugins which are implemented as standalone binary applications.
rpc
scriptpack Package scriptpack is used to work with "ScriptPacks" which are packages of shell scripts that app types can define and use to get things done on the remote machine, whether its for development or deployment.
scriptpack/test-basic
ui