diff --git a/docs-old/README.md b/docs-old/README.md new file mode 100644 index 00000000000..62a8e27886b --- /dev/null +++ b/docs-old/README.md @@ -0,0 +1,17 @@ +# Table of Contents + +* [Read Me](../README.md) +* [Introduction](./introduction/README.md) + * [Getting Started](./introduction/getting-started.md) + * [Motivation](./introduction/motivation.md) +* [Guides](./guides/README.md) + * [Configuration](./guides/configuration.md) + * [Using Garden with Minikube](./guides/minikube.md) + * [Remote Kubernetes](./guides/remote-kubernetes.md) + * [Glossary](./guides/glossary.md) +* [Reference](./reference/README.md) + * [Commands](./reference/commands.md) + * [Config](./reference/config.md) +* [Examples](./examples/README.md) + * [Simple Project](./examples/simple-project.md) +* [FAQs](./faqs.md) \ No newline at end of file diff --git a/docs-old/examples/README.md b/docs-old/examples/README.md new file mode 100644 index 00000000000..1fcbf2b2ebf --- /dev/null +++ b/docs-old/examples/README.md @@ -0,0 +1,6 @@ +# Examples + +The source code for the examples in this section can be found in our Github repository under the +[examples directory](https://github.com/garden-io/garden/tree/master/examples). + +* [Simple Project](./simple-project.md) \ No newline at end of file diff --git a/docs-old/examples/simple-project.md b/docs-old/examples/simple-project.md new file mode 100644 index 00000000000..60b9842968c --- /dev/null +++ b/docs-old/examples/simple-project.md @@ -0,0 +1,309 @@ +# Simple Project + +In this guide, we'll walk you through configuring a simple project to run on the Garden framework. The project will consist of two Dockerized web services that communicate with one another, along with unit and integration tests. + +In what follows you'll learn how to: + +* [Configure the project](#project-wide-configuration) +* [Configure individual modules](#module-configuration) +* [Deploy the project locally](#deploying) +* [Have the services communicate with one another](#inter-service-communication) +* [Manage service dependencies](#dependencies) +* [Test services](#testing) + +## Before you get started + +This tutorial assumes that you have already have a running [installation of Garden](../introduction/getting-started.md). + +## Clone the example repo + +The code for this tutorial can be found in our Github repository under the [examples directory](https://github.com/garden-io/garden/tree/master/examples). We'll use the [simple-project-start](https://github.com/garden-io/garden/tree/master/examples/simple-project-start/) example and work our way from there. The complete version is under [simple-project](https://github.com/garden-io/garden/tree/master/examples/simple-project). + +First, let's clone the examples repo, change into the directory, and take a look inside: +```sh +$ git clone https://github.com/garden-io/garden/examples.git +$ cd garden/examples/simple-project-start +$ tree . +. +└── services + ├── go-service + │   ├── Dockerfile + │   └── webserver + │   └── main.go + └── node-service + ├── Dockerfile + ├── app.js + ├── main.js + ├── package.json + └── test + └── integ.js + +5 directories, 7 files + ``` + +As you can see the project consists of two super simple services and their accompanying Dockerfiles. One of the core tenets of multi-service backends is being able to pick the right tool for the job, and therefore we have a Node.js service and a Golang service, that we can pretend have different responsibilities. + +The task at hand is to configure these services so that they can run on the Garden framework. + +## Project-wide configuration + +To begin with, every project needs a project-wide `garden.yml` [configuration file](../guides/configuration.md#Config) at the root level. There we define, among other things, the name of the project, and the [providers](../guides/glossary.md#Provider) used for each [plugin](../guides/glossary.md#Plugin) the project requires. + +Let's go ahead and create one: + +```sh +$ touch garden.yml +``` + +and add the following configuration: + +```yaml +project: + name: simple-project + environments: + - name: local + providers: + - name: local-kubernetes +``` + +Above, we've specified the name of our project and configured it to use the local-kubernetes plugin for local development. Note, that this file must be located in the project root directory. + +## Module configuration + +Now, let's turn to our services. Services live inside [modules](../guides/glossary.md#Module), and each module has it's own `garden.yml` configuration file. + +We'll start with the module for the `node-service`: + +```sh +$ touch services/node-service/garden.yml +``` + +and add the following: + +```yaml +module: + description: Node service container + type: container +``` + +By running the `scan` command we can see that Garden detects our module config: + +```sh +$ garden scan +- name: node-service + type: container + path: /Users/eysi/code/simple-project/services/node-service + description: Node service container + version: + versionString: 2c8818986d-1528373640 + latestCommit: 2c8818986d + dirtyTimestamp: 1528373640 +``` + +Under the `module` directive of our `services/node-service/garden.yml` file we can now specify how to run our service: + +```yaml +module: + description: Node service container + type: container + services: + - name: node-service + command: [npm, start] + ports: + - name: http + containerPort: 8080 + endpoints: + - path: /hello-node + port: http +``` +The [services](../guides/configuration.md#Services) directive is specific to container modules, and defines the services exposed by the module. In this case, our containerized Node.js server. The sub-directives tell Garden how to start the service and which endpoints to expose. + +## Deploying + +With this configuration we're almost ready to deploy. First, we'll need to create a user namespace for our environment with the login command: + +```sh +$ garden login +``` + +Garden can now deploy our service to a local Kubernetes cluster: + +```sh +$ garden deploy +``` + +To verify that everything is working, we can call the service at the `/hello-node` endpoint defined in `/services/node-service/app.js`: + +```sh +$ garden call node-service/hello-node +✔ Sending HTTP GET request to http://simple-project.local.app.garden/hello-node + +200 OK + +Hello from Node server! +``` + +In a similar manner, we create a config file for our `go-service`: + +```sh +$ touch services/go-service/garden.yml +``` + +and add the following: + +```yaml +module: + description: Go service container + type: container + services: + - name: go-service + ports: + - name: http + containerPort: 80 + endpoints: + - path: /hello-go + port: http +``` + +Run the deploy command again, this time only for the `go-service`: + +```sh +$ garden deploy go-service +``` + +Another way to verify that our services are up and running is to have a look at the service logs. We can either get an aggregate from all our services, by running `garden logs`, or we can specify a list of services. This time we're only interested in our `go-service`: + +```sh +$ garden logs go-service +go-service → 2018-06-07T12:52:41.075Z → Server running... +``` + +Looks good! Let's take stock: + +* We started out with a project consisting of multiple containerized services (really just two, but hey, it's a _simple_ project). +* We added a project wide configuration at the root level, and a module configuration for each service. +* We deployed our entire project with the `garden deploy` command +* We saw how we could call our services and read their logs with the `garden call` and `garden logs` commands. + +## Inter-service communication + +Calling our `go-service` from our `node-service` is straightforward from within the application code. Crack open `services/node-service/app.js` with your favorite editor and add the following: + +```javascript +const request = require('request-promise') + +// Unless configured otherwise, the hostname is simply the service name +const goServiceEndpoint = `http://go-service/hello-go`; + +app.get('/call-go-service', (req, res) => { + // Query the go-service and return the response + request.get(goServiceEndpoint) + .then(message => { + res.json({ + message, + }) + }) + .catch((err) => { + res.statusCode = 500 + res.json({ + error: err, + message: "Unable to reach service at " + goServiceEndpoint, + }) + }) +}) +``` + +Now let's re-deploy the `node-service` and try out our new endpoint: + +```sh +$ garden deploy node-service +$ garden call node-service/call-go-service +✔ Sending HTTP GET request to http://simple-project.local.app.garden/call-go-service + +200 OK + +{ + "message": "Hello from Go!" +} +``` + +Nice! + +So far, we've seen how to configure a simple project and it's modules, how to deploy our services, and how these services can communicate. Next, let's take a look at how we can define dependencies and set up testing. + +## Dependencies + +An attentive reader will no doubt have noticed that our `node-service` depends on the `go-service` for it's `call-go-service` endpoint. We can express this in the `node-service` module configuration by adding `dependencies` under the `services` directive: + +```yaml +module: + description: Node service container + ... + services: + - name: node-service + command: [npm, start] + ... + dependencies: + - go-service +``` + +This will ensure that our `go-service` will be deployed before the `node-service`. + +## Testing + +Finally, we'll update our `node-service` module configuration to tell Garden how to run our tests. Add the following test config under the `module` directive in `services/node-service/garden.yml`: + +```yaml +module: + description: Node service container + ... + services: + - name: node-service + command: [npm, start] + ... + tests: + - name: unit + command: [npm, test] + - name: integ + command: [npm, run, integ] + dependencies: + - go-service +``` + +This allows us to run individual test groups by name or all of them at once with the test command: + +```sh +$ garden test +``` + +Notice also that the integration test depends on the `go-service` being deployed. + +The entire module config should now look like this: + +```yaml +module: + description: Node service container + type: container + services: + - name: node-service + command: [npm, start] + ports: + - name: http + containerPort: 8080 + endpoints: + - path: / + port: http + dependencies: + - go-service + tests: + - name: unit + command: [npm, test] + - name: integ + command: [npm, run, integ] + dependencies: + - go-service +``` + +And that's it! Our services are up and running locally, dependencies are resolved, and tests are ready to run. + +Check out some of our other [Guides](../guides/README.md) for more of an in-depth look at the Garden framework. \ No newline at end of file diff --git a/docs-old/faqs.md b/docs-old/faqs.md new file mode 100644 index 00000000000..9b92ecddb13 --- /dev/null +++ b/docs-old/faqs.md @@ -0,0 +1,6 @@ +# Frequently Asked Questions + +### When using garden inside tmux, colors look wonky. What gives? + +You need to set tmux to use 256 colors. As per the [official documentation](https://github.com/tmux/tmux/wiki/FAQ#how-do-i-use-a-256-colour-terminal), you +can do that by adding `set -g default-terminal "screen-256color"` or `set -g default-terminal "tmux-256color"` to your `~/.tmux.conf` file. diff --git a/docs/garden-banner-logotype-left-2.png b/docs-old/garden-banner-logotype-left-2.png similarity index 100% rename from docs/garden-banner-logotype-left-2.png rename to docs-old/garden-banner-logotype-left-2.png diff --git a/docs/guides/README.md b/docs-old/guides/README.md similarity index 100% rename from docs/guides/README.md rename to docs-old/guides/README.md diff --git a/docs/guides/configuration.md b/docs-old/guides/configuration.md similarity index 100% rename from docs/guides/configuration.md rename to docs-old/guides/configuration.md diff --git a/docs/guides/glossary.md b/docs-old/guides/glossary.md similarity index 100% rename from docs/guides/glossary.md rename to docs-old/guides/glossary.md diff --git a/docs/guides/minikube.md b/docs-old/guides/minikube.md similarity index 100% rename from docs/guides/minikube.md rename to docs-old/guides/minikube.md diff --git a/docs/guides/remote-kubernetes.md b/docs-old/guides/remote-kubernetes.md similarity index 100% rename from docs/guides/remote-kubernetes.md rename to docs-old/guides/remote-kubernetes.md diff --git a/docs/introduction/README.md b/docs-old/introduction/README.md similarity index 100% rename from docs/introduction/README.md rename to docs-old/introduction/README.md diff --git a/docs-old/introduction/getting-started.md b/docs-old/introduction/getting-started.md new file mode 100644 index 00000000000..e0d58c1006d --- /dev/null +++ b/docs-old/introduction/getting-started.md @@ -0,0 +1,42 @@ +# Getting Started + +This guide will walk you through setting up the Garden framework. + +Please follow the guide for your operating system: + +* [macOS](#macos) +* [Windows](#windows) +* [Linux (or manual installation on other platforms)](#linux-manual-installation) + +## Using the CLI + +With the CLI installed, we can now try out a few commands using the [hello-world](https://github.com/garden-io/garden/examples/tree/master/simple-project) project from our Github [examples repository](https://github.com/garden-io/garden/examples). The example consists of a a couple of simple services. + +_Note: check if Kubernetes is running with `kubectl version`. You should see both a `Client Version` and a `Server Version` in the response. If not, please start it up before proceeding._ + +Clone the repo and change into the `hello-world` directory: + +```sh +$ git clone https://github.com/garden-io/garden/examples.git +$ cd garden/examples/hello-world +``` + +First, let's check the environment status by running the following from the project root: + +```sh +$ garden status +``` + +The response tells us how the environment is configured and the status of the providers. Next, we'll deploy the services with: + +```sh +$ garden deploy +``` + +And that's it! The services are now running on the Garden framework. You can see for yourself by querying the `/hello` endpoint of the container with: + +```sh +$ garden call hello-container/hello +``` + +Check out our [Commands guide](../guides/commands.md) for other features like auto-reload, streaming service logs, running tests and lots more, or see how a Garden project is configured from scratch in our [Simple Project](../guides/simple-project.md) guide. \ No newline at end of file diff --git a/docs/introduction/motivation.md b/docs-old/introduction/motivation.md similarity index 100% rename from docs/introduction/motivation.md rename to docs-old/introduction/motivation.md diff --git a/docs-old/reference/README.md b/docs-old/reference/README.md new file mode 100644 index 00000000000..aa067ae31dc --- /dev/null +++ b/docs-old/reference/README.md @@ -0,0 +1,5 @@ +# Reference + +* [Commands](./commands.md) +* [Config](./config.md) +* [Template strings](./template-strings.md) diff --git a/docs/reference/commands.md b/docs-old/reference/commands.md similarity index 100% rename from docs/reference/commands.md rename to docs-old/reference/commands.md diff --git a/docs/reference/config.md b/docs-old/reference/config.md similarity index 100% rename from docs/reference/config.md rename to docs-old/reference/config.md diff --git a/docs/reference/template-strings.md b/docs-old/reference/template-strings.md similarity index 100% rename from docs/reference/template-strings.md rename to docs-old/reference/template-strings.md diff --git a/docs/README.md b/docs/README.md index d7b1654595f..8652c49885f 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,17 +1,87 @@ -# Table of Contents - -* [Read Me](../README.md) -* [Introduction](./introduction/README.md) - * [Getting Started](./introduction/getting-started.md) - * [Motivation](./introduction/motivation.md) -* [Guides](./guides/README.md) - * [Configuration](./guides/configuration.md) - * [Using Garden with Minikube](./guides/minikube.md) - * [Remote Kubernetes](./guides/remote-kubernetes.md) - * [Glossary](./guides/glossary.md) -* [Reference](./reference/README.md) - * [Commands](./reference/commands.md) - * [Config](./reference/config.md) -* [Examples](./examples/README.md) - * [Simple Project](./examples/simple-project.md) -* [FAQs](./faqs.md) +[![CircleCI](https://circleci.com/gh/garden-io/garden/tree/master.svg?style=svg&circle-token=ac1ec9984d093f91e594e5a0a03b34cec2c2a093)](https://circleci.com/gh/garden-io/garden/tree/master) + + +![](docs/garden-banner-logotype-left-2.png) + +*Welcome! Garden is a full-featured development framework for containers and serverless backends, designed to make +it easy to develop and test distributed systems.* +

+ +### Status + +The project is in _early alpha_ (or developer preview, if you prefer). This means APIs may well change (not drastically, but still), overall stability will improve and platform support is still limited. + +All that said, Garden can already be highly useful if the following applies to you: + +* **You're deploying to (or transitioning to) Kubernetes.** +* **You really don't want to spend your precious hours building your own developer tooling!** + +If that sounds right for you, please give it a go and don't hesitate to report issues. + + +## Features + +With Garden, you can... + +* Configure and deploy a fleet of services to a local Kubernetes cluster using simple declarations. +* Use an integrated framework for building, testing and deploying services. +* Easily run end-to-end tests across multiple services without waiting for a slow CI pipeline. +* Automatically build, deploy and/or test when your code changes, using the `--watch` flag or the `garden dev` command. +* Manage build and runtime dependencies across all your services. +* Leverage a suite of commands and helpers to facilitate developing and running your stack. +* _Write code the way you want, and run your production system however suits you! Garden does not impose any new libraries or languages aside from the config files._ + +Garden is also designed to be pluggable and modular, with Kubernetes being just one plugin (albeit an important one). Over time we will add native support for a variety of platforms, including AWS (Lambda, ECS, Fargate and more), GCP, Heroku... and the list will continue growing. + + +## Usage + +Head over to our [Quick Start guide](https://docs.garden.io/basics/getting-started/quick-start), and then look through our [Simple Project](https://docs.garden.io/examples/simple-project) guide to get a quick sense of how everything works. + +For a more in-depth approach, just keep reading this documentation. + +[![asciicast](https://asciinema.org/a/SKI7qe7DFVVHxvoaIVrLPb6Es.png)](https://asciinema.org/a/SKI7qe7DFVVHxvoaIVrLPb6Es?speed=2) + +## Contributing + +We welcome any and all contributions to Garden! What we're trying to achieve is a big task, and +developers have a lot of diverse needs, so we need and appreciate your input, whether it's through +code, docs, issues or developing plugins for your needs. + +For more detailed guidelines, see [CONTRIBUTING.md](CONTRIBUTING.md). + + +# Motivation + +The landscape of server-side development has changed immensely over the last decade. +This has partly been driven by evolving needs — **scalability has become table-stakes for most +projects and companies** — and also by the rapid development and proliferation of new technologies +like containers. + +From an operations standpoint, all of this is fantastic. Scaling out is increasingly simple +and cost-effective, and managing production systems is easier than ever. So much so, that the +notion of DevOps has caught on — if ops is so easy, why not have the developers do it +themselves? + +And the promise of it all is great. Microservices, immutable infrastructure, continuous +integration and deployment, all that jazz. Trouble is, all this tends to come at the expense +of application developer productivity. In embracing these new technologies and tools, we've +_over-optimized for ops, and in turn made it more difficult and tedious to work on the actual +application code_. + +Now, rather than lament and pine for the good ol' monolith days, we at Garden feel that this can +be addressed by **a new generation of developer tooling**. So that's what we've set out to make. +It's certainly not a trivial task, but we truly believe that it's possible to not only reclaim the +rapid feedback loops we're used to when developing individual services, but to go further and +leverage the benefits of modern backend platforms to make development easier and faster than ever. + +So think of Garden as the missing layer on top of Kubernetes, AWS, GCP, etc., that focuses purely +on the **developer experience**, makes it trivial to work across multiple platforms, and closes the +gap between infrastructure and application development. + +We do this by frameworking around the basic primitives of development — building, testing, +debugging and deploying — and making the _how_ of each of those pluggable and configurable. +This allows the framework to grow with you and adapt as your needs evolve in terms of how you +architect and run your code in production, and allows us to easily tie together all the amazing +open-source tools that are being developed in the ecosystem, into an **integrated, consistent +and easy-to-use development framework**. diff --git a/docs/basics/README.md b/docs/basics/README.md new file mode 100644 index 00000000000..f0c272935ff --- /dev/null +++ b/docs/basics/README.md @@ -0,0 +1,11 @@ +# Basics + +The following articles cover the basics of installing and using Garden: + + * Installation instructions for your platform: [Installation](./basics/installation.md). + * A very brief guide on the main commands you should be familiar with, and an example project to test them in: [Quick Start](./basics/quick-start.md). + * An overview of the framework's main concepts, to help get you started using Garden with your own projects: [Concepts](./basics/concepts.md). + +If you're already familiar with the basics, feel free to move on to the next chapter: [Using Garden](./using-garden/README.md). + +Or dive right in by exploring our [Guides](./guides/README.md) and [Example projects](./examples/README.md). diff --git a/docs/basics/concepts.md b/docs/basics/concepts.md new file mode 100644 index 00000000000..3b9e2478d14 --- /dev/null +++ b/docs/basics/concepts.md @@ -0,0 +1,51 @@ +# How Garden works + +The mechanics for how Garden works are fundamentally straight forward: + +The main functionality is housed under what we call providers. We have, for example, a provider for containers, one for OpenFaaS, one for Kubernetes, and providers are how we control the behavior of these different types of tools. + +Garden projects, in turn, consist of modules. Each module in a project has a type (e.g. container, OpenFaaS), and the type then indicates which provider should deal with each specific module when it comes to building, deploying, and testing it. + +This information is conveyed through [configuration files](../using-garden/configuration-files.md), usually in YAML format, which live in the project root for project-wide settings, and in each module's directory (for module-specific settings). + +# Projects vs. modules vs. services + +Garden has three main organizational units: projects, modules, and services. + +A project is the largest unit, and it contains all the others. You can think of a project as a context: there aren't any hard rules or limitations as to how big or small your project should be, but it's advisable to keep all elements belonging to a same context inside the same project. + +Modules can be thought of as build units. So, for example, every container and every serverless function should, as a rule of thumb, have its own module. + +Lastly, services are units of deployment, or instances. They're *usually* one per module, but not necessarily: you might have, for example, two instances of the same container working on different queues or data streams. + +To sum it all up: A project consists of one or modules, and each module may deploy zero or more services. + +# The build → test → deploy sequence + +One of the main tools of Garden to make the development of distributed systems extremely agile is the developer framework. You can call with `garden dev`. + +It is a combination of the `build`, `deploy` and `test` commands, that is, it builds, deploys and tests all your modules and services, and re-builds, re-deploys and re-tests as you modify the code. + +The `build`, `deploy` and `test` commands, and by extension the `dev` command, are all dependency-aware. They will always build, test, and deploy modules in the right order so that all dependencies are respected. + +# How inter-service communication works + +Arguably the most important thing a distributed system needs to do is to allow its different parts to talk to one another. Garden makes inter-service communication extremely simple: a service's hostname is simply its name as declared in the configuration file. + +For example, if you have a service called `my-service`, you can access its `/feature` endpoint by simply calling `http://my-service/feature`. + +# Hot reload + +Hot reloading is updating a running service when its source files are changed, without re-building and re-deploying the whole thing. + +In the case of a container, for example, we would not destroy the container, change the files, and then re-deploy a new container. Instead, we would update the changed files without stopping the running container, thus potentially not losing the current state of the application. + +Hot reload is off for all modules by default, and it needs to be enabled with the `hotReload` field a module's configuration file. For more detailed information, see the [configuring hot reload](./guides/configuring-hot-reload.md) guide. + +# Projects with multiple and/or remote repositories + +Garden projects may include sources hosted in any number of local or remote repositories. Remote sources may be later linked to local directories for convenience or to work offline. + +You could have, for example, a project that has one local module, then one remote module from an external source, and then a second external source that contains, let's say, two more modules. + +For specifics see our [Remote sources project](../examples/remote-sources.md) example. \ No newline at end of file diff --git a/docs/basics/installation.md b/docs/basics/installation.md new file mode 100644 index 00000000000..c30f0464cb7 --- /dev/null +++ b/docs/basics/installation.md @@ -0,0 +1,175 @@ +## Installation + +This guide will walk you through setting up the Garden framework. + +Please follow the guide for your operating system: + +* [macOS](#macos) +* [Windows](#windows) +* [Linux (Manual Installation)](#linux-manual-installation) + +And if you decide to use Minikube, please see our [Minikube Instructions](#minikube-instructions) further down this +document. + +### macOS + +For Mac, we recommend the following steps to install Garden. You can also follow the manual installation +steps below if you prefer. + +#### Step 1: Install homebrew + +If you haven't already set up homebrew, please follow [their instructions](https://brew.sh/) to set it up. + +#### Step 2: Docker and local Kubernetes + +To install Docker, Kubernetes and kubectl, we strongly recommend Docker for Mac (edge version). + +_Note: you need to install the **edge version** of Docker for Mac to enable Kubernetes support._ + +Once installed, open the Docker for Mac preferences, go to the Kubernetes section, +tick `Enable Kubernetes` and save. Please refer to their +[installation guide](https://docs.docker.com/engine/installation/) for details. + +Alternatively, you can use Minikube. We generally find it less stable and more hassle to +configure and use, but we do fully support it on Mac. Please look at the +[Minikube Instructions](#minikube-instructions) section for details. + +#### Step 3: Install `garden-cli` + +We have a Homebrew tap and package that you can use to easily install `garden-cli` and all dependencies: + +```sh +brew tap garden-io/garden +brew install garden-cli +``` + +To later upgrade to the newest version, simply run `brew update` and then `brew upgrade garden-cli` +(or `brew upgrade` to upgrade all your Homebrew packages). + +### Windows + +You can run Garden on Windows 10 Pro or Enterprise editions (unfortunately, the Home edition does not work, because it +does not support virtualization). To install the Garden CLI, please use our _automated installation script_, which will +check for dependencies, install missing dependencies if needed, and finally install the `garden-cli` npm package. + +The script will check for the following: + +* The [Chocolatey](https://chocolatey.org) package manager. +* Whether you have Hyper-V enabled. This is required for _Docker for Windows_. If you do not already have it enabled, + the script will enable it (you will then need to restart your computer before starting Docker for Windows). +* Docker - We strongly recommend using the _Edge version_ of + [Docker for Windows](https://www.docker.com/docker-windows), which has built-in support for Kubernetes. Garden also supports different configurations of Docker and Kubernetes, using Minikube for example, but + Docker for Windows is generally easier to install and configure, and is well supported. The script will check if Docker is + installed, and whether Kubernetes has been enabled as the default orchestrator. +* Node.js - The script will install it via Chocolatey if it is missing. _If you already have Node.js + installed, please make sure it is version 8.x or newer._ +* Git and rsync - The script will install those if they are missing. + +To run the script, open PowerShell as an Administrator and run: + +```PowerShell +Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/garden-io/garden/master/garden-service/support/install.ps1')) +``` + +To later upgrade to the newest version, run `npm install -g -U garden-cli`. + +### Linux (manual installation) + +You need the following dependencies on your local machine to use Garden: + +* Node.js >= 8.x +* [Docker](https://docs.docker.com/) +* Git +* rsync +* Local installation of Kubernetes and kubectl + +#### Step 1: Docker + +To install Docker, please follow the instructions in the [official documentation](https://docs.docker.com/install/). + +#### Step 2: Local Kubernetes + +For local Kubernetes, you can use [Minikube](https://github.com/kubernetes/minikube). Please see our +[Minikube Instructions](#minikube-instructions). + +#### Step 3: Install other dependencies + +Use your preferred method or package manager to install `node` (version 8.x or higher), `git`, and `rsync`. + +On Ubuntu 18, you'd do `sudo apt install git rsync` for Git and rsync. + +To install Node, we recommend using nvm. You can install nvm e.g. by executing the following in a shell: +```sh +curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash +``` +and restarting your terminal. You can then install Node via `nvm install node`. + +#### Step 4: Install `garden-cli` + +Once you have the dependencies set up, install the Garden CLI via `npm`: + +```sh +npm install -g garden-cli +``` + +To later upgrade to the newest version, run `npm install -g -U garden-cli`. + + +# Minikube Instructions + +Garden can be used with [Minikube](https://github.com/kubernetes/minikube) on supported platforms. + +_NOTE: We highly recommend using Docker for Mac and Docker for Windows, for macOS and Windows respectively._ + +## Installation + +For Minikube installation instructions, please see the [official guide](https://github.com/kubernetes/minikube#installation). + +You'll likely also need to install a driver to run the Minikube VM, please follow the +[instructions here](https://github.com/kubernetes/minikube/blob/master/docs/drivers.md) +and note the name of the driver you use. The driver you choose will likely vary depending on your +OS/platform. We recommend [hyperkit](https://github.com/kubernetes/minikube/blob/master/docs/drivers.md#hyperkit-driver) +for macOS and [kvm2](https://github.com/kubernetes/minikube/blob/master/docs/drivers.md#kvm2-driver) on most Linux +platforms. + +Once Minikube and the appropriate driver for your OS is installed, you can start it by running: + +```sh +minikube start --vm-driver= # e.g. hyperkit on macOS +``` + +You'll also need to have Docker (for macOS, we recommend [Docker for Mac](https://docs.docker.com/engine/installation/)) +and [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/) installed. + +## Usage + +The `local-kubernetes` plugin attempts to automatically detect if it is installed and set the appropriate context +for connecting to the local Kubernetes instance. In most cases you should not have to update your `garden.yml`, +since it uses the `local-kubernetes` plugin by default, but you can configure it explicitly in your project-level +`garden.yml` as follows: + +```yaml +project: + environments: + - name: local + providers: + - name: local-kubernetes + context: minikube +``` + +If you happen to have installed both Minikube and a version of Docker for Mac with Kubernetes support enabled, +`garden` will choose whichever one is configured as the current context in your `kubectl` configuration, and if neither +is set as the current context, Docker for Mac is preferred by default. + +(If you're not yet familiar with Garden configuration files, see: [Configuration files](../using-garden/configuration-files.md)) + +## Hostname + +Garden needs the Kubernetes instance to have a hostname. By default Garden will use `.nip.io`. If you'd +like to use a custom hostname, you can specify it via the `ingressHostname` in the `local-kubernetes` provider config +(see above). + +## Anything else? + +Once the above is set up, the `local-kubernetes` plugin will automatically configure everything else Garden needs to +work. The built-in nginx ingress controller will be automatically enabled and used to route requests to services. diff --git a/docs/basics/quick-start.md b/docs/basics/quick-start.md new file mode 100644 index 00000000000..585b3c33080 --- /dev/null +++ b/docs/basics/quick-start.md @@ -0,0 +1,58 @@ +# Getting Started + +This guide will walk you through setting up the Garden framework. It assumes you already have Garden installed. If you don't, please check out our [installation guide](./installation.md). + +## Using the CLI + +With the CLI installed, we can now try out a few commands using the [Simple Project](../examples/simple-project.md) from our [example projects](../examples/README.md). The example project consists of a couple of simple modules, each defining one service. + +_Note: Check if Kubernetes is running with `kubectl version`. You should see both a `Client Version` and a `Server Version` in the response. If not, please start it up before proceeding._ + +Clone the repo and change into the `simple-project` directory: + +```sh +$ git clone https://github.com/garden-io/garden.git +$ cd garden/examples/simple-project +``` + +First, let's check the environment status by running the following from the project root: + +```sh +$ garden get status +``` + +The response tells us how the environment is configured and the status of the providers. Next, we'll build our modules with: + +```sh +$ garden build +``` + +This builds Docker images for `go-service` and `node-service` respectively. Next, we'll deploy the services with: + +```sh +$ garden deploy +``` + +And that's it! The `garden build` step above is actually unnecessary (only included here for clarity), since `garden deploy` will also rebuild modules as needed. The services are now running on the Garden framework. You can see for yourself by querying the `/hello` endpoint of `go-service`'s running container: + +```sh +$ garden call go-service/hello-go +``` + +To run tests for all modules: + +```sh +$ garden test +``` + +And if you prefer an interactive terminal that watches your project for changes and re-builds, re-deploys, and re-tests automatically, try: + +```sh +$ garden dev +``` + +Go ahead, leave it running and change one of the files in the project, then watch it re-build. + +That's it for now. Check out our [Using Garden](../using-garden/README.md) section for other features like hot reload, remote clusters, integration tests, and lots more. + +To see how a Garden project is configured from scratch check, out the [Simple Project](../examples/simple-project.md) guide for a more in-depth presentation. diff --git a/docs/contributing.md b/docs/contributing.md new file mode 100644 index 00000000000..e10b3699789 --- /dev/null +++ b/docs/contributing.md @@ -0,0 +1,92 @@ +!!! WORK IN PROGRESS !!! + +# README.md + +This is the source code for the garden framework. + +Here's a high-level overview of how the whole thing works: + +![](schematic.jpg) + +The main components are plugins, projects, and the framework itself. + +### Projects + +Projects are your user's files. A project is composed of modules, which are in turn composed of services. + +Let's see our [hello-world](https://github.com/garden-io/garden/tree/master/examples/hello-world) example: + - It has two modules, `hello-container` and `hello-function`. + - `hello-container` contains one service, named `hello-container`. + - `hello-function` also contains only one service, named `hello-function`. + +Just as you may have many modules per project, you may have many services per module. + +Beware that no two services may have the same name in the project. (You could want to, for example, have a `logging` service on multiple modules. In this case you'll need a different name for each.) + +### Plugins + +Plugins are garden's way of knowing what to do about each module in a project. The way a container behaves is different than a serverless function, for example, and plugins are the way to define those different behaviours. + +Plugins interact with the project via the plugin interface. For more detailed information, see the README.md file in the plugin directory. + +### The Framework + +In the context of projects and plugins, what the framework does is: + + 1. Watch project files for changes + 2. Provide plugins with context so they can operate on the project + 3. Keep track of state as multiple plugins work independently + +# Plugins + +To define a plugin you need to return a `GardenPlugin` object, and then declare that on the `builtinPlugins` object on the `garden/src/plugins/plugins.ts` file. + +`GardenPlugin` is an interface that lives on `garden/src/types/plugin/plugin.ts`: + +```typescript +export interface GardenPlugin { + config?: object + configKeys?: string[] + + modules?: string[] + + actions?: Partial + moduleActions?: { [moduleType: string]: Partial } +} +``` + +The way your plugin interacts with the rest of the world is via actions. These can be of three types: plugin actions, module actions, and service actions. They are: + +Plugin Actions: + + - getEnvironmentStatus + - configureEnvironment + - destroyEnvironment + - getConfig + - setConfig + - deleteConfig + - getLoginStatus + - login + - logout + +Module Actions: + + - parseModule + - getModuleBuildStatus + - buildModule + - pushModule + - runModule + - testModule + - getTestResult + +Service Actions: + + - getServiceStatus + - deployService + - getServiceOutputs + - execInService + - getServiceLogs + - runService + + + diff --git a/docs/examples/README.md b/docs/examples/README.md index 1fcbf2b2ebf..2d9f17faf9f 100644 --- a/docs/examples/README.md +++ b/docs/examples/README.md @@ -1,6 +1,17 @@ -# Examples +# Example projects -The source code for the examples in this section can be found in our Github repository under the -[examples directory](https://github.com/garden-io/garden/tree/master/examples). +## [Hello world](./hello-world.md) -* [Simple Project](./simple-project.md) \ No newline at end of file +In this project we see in practice the basics of configuring dependencies, defining ports and endpoints, and setting up tests. + +## [Simple project](./simple-project.md) + +Here we see how to "gardenify" a pre-existing project, creating a project config and the individual module configs for every part. + +## [TLS project](./tls-project.md) + +This is an example project of how to set up TLS using the `mkcert` tool. + +## [Remote sources project](./remote-sources.md) + +This project demonstrates how to use multiple sources and repositories together into the same project. Although in this project we're using _remote_ sources, the same applies to using multiple _local_ repositories. \ No newline at end of file diff --git a/docs/examples/hello-world.md b/docs/examples/hello-world.md new file mode 100644 index 00000000000..64ae919e71c --- /dev/null +++ b/docs/examples/hello-world.md @@ -0,0 +1,127 @@ +# Hello World + +In this example, we'll have a practical look at the main characteristics of a Garden project: + +- Dependencies +- Ports, endpoints, and health check settings +- Tests + +This project contains four configuration files. [This one](https://github.com/garden-io/garden/tree/master/examples/hello-world/garden.yml) for project-wide settings, and three separate ones for each of the modules: [`hello-container`](https://github.com/garden-io/garden/tree/master/examples/hello-world/services/hello-container/garden.yml), [`hello-function`](https://github.com/garden-io/garden/tree/master/examples/hello-world/services/hello-function/garden.yml), and [`hello-npm-package`](https://github.com/garden-io/garden/tree/master/examples/hello-world/libraries/hello-npm-package/garden.yml). + +# Configuring dependencies + +There are three main types of dependencies we'll be dealing with: build dependencies, runtime dependencies, and test dependencies. + +You can think of build dependencies as libraries. For example, our `hello-world/services/hello-container/app.js` file in the `hello-container` module requires the `hello-npm-package` to be imported: + +```js +const hello = require("./libraries/hello-npm-package") +``` + +For `hello-npm-package` to be imported by `hello-container`, of course, it needs to be built first. Thus, we specify it as a build dependency. Take a look at its `config.yml`: + +```yml + build: + dependencies: + - name: hello-npm-package + copy: + - source: "./" + target: libraries/hello-npm-package/ +``` + +_Note: `source` refers to the path on the dependency module being specified, and `target` refers to where it will be accessed from by the dependant module (picture it as a mount directory)._ + +Runtime dependencies, on the other hand, are irrelevant at build time, but required for execution. For example, as we can see on the `app.js` file, the `hello-container` module depends on `hello-function` being up and running: + +```js +const functionEndpoint = process.env.GARDEN_SERVICES_HELLO_FUNCTION_ENDPOINT +``` + +So let's see how to make sure `hello-function` is running before `hello-container`: + +```yaml +module: + description: Hello world container service + type: container + name: hello-container + services: + ... + dependencies: + - hello-function +``` + +Test dependencies will be covered further ahead. + +# Defining ports, endpoints, and health checks + +Before we can define our endpoints and health checks we'll to define the ports we'll be working with. For example, below we'll assign the name `http` to port number `8080`: + +```yml +module: + description: Hello world container service + ... + services: + ... + ports: + - name: http + containerPort: 8080 +``` + +Now let's use that port and a path to define an ingress endpoint for the service to expose: + +```yml +module: + description: Hello world container service + ... + services: + ... + ports: + - name: http + containerPort: 8080 + endpoints: + - path: /hello + port: http +``` + +Lastly, health checks currently have three possible types: `httpGet`, `command`, and `tcpPort`. They're specified in the [Config Files Reference](../reference/config-files-reference.md). + +For the Hello World project, we'll use the first one. This `healthCheck` endpoint will be pinged periodically to ensure that the service is still healthy. Here's what it looks like: + +```yml +module: + description: Hello world container service + ... + services: + ... + ports: + - name: http + containerPort: 8080 + endpoints: + - path: /hello + port: http + healthCheck: + httpGet: + path: /_ah/health + port: http +``` + +# Setting up tests + +Since Garden is language-agnostic, there aren't any low level requirements about how tests should be arranged. The only requirements are: + +- You must be able to execute a command to run your tests. +- Any non-zero exit codes returned by the command mean your tests have failed, and zero indicates the tests are passing. + +The only difference between unit tests and integration tests, then, are that to run the latter you might need other services to be up and running as well. You can specify them as test dependencies. + +Here's what it looks like in practice: + +```yml + tests: + - name: unit + command: [npm, test] + - name: integ + command: [npm, run, integ] + dependencies: + - hello-function +``` \ No newline at end of file diff --git a/docs/examples/remote-sources.md b/docs/examples/remote-sources.md new file mode 100644 index 00000000000..223ff010c02 --- /dev/null +++ b/docs/examples/remote-sources.md @@ -0,0 +1,106 @@ +# Remote sources example project + +This example demonstrates how you can import remote sources and remote modules into a Garden project. + +_Note: To use multiple local repositories—not remote, as this article describes—simply utilize `file:///my/other/project/path` in the `repositoryUrl` field described below._ + +Important concepts: + +> Remote _source_: A collection of one or more Garden modules that live in a repository different from the main project repository. The `garden.yml` config files are co-located with the modules in the remote repository. + +> Remote _module_: The remote source code for a single Garden module. In this case, the `garden.yml` config file is stored in the main project repository while the module code itself is in the remote repository. + +## About + +This project is the same as the [multi-container example](https://github.com/garden-io/garden/tree/master/examples/multi-container)—except that in this case the services live in their own repositories. The repositories are: + +* [Database services](https://github.com/garden-io/garden-example-remote-sources-db-services) (contains the Postgres and Redis services) +* [Web services](https://github.com/garden-io/garden-example-remote-sources-web-services) (contains the Python Vote web service and the Node.js Result web service) +* [Java worker module](https://github.com/garden-io/garden-example-remote-module-jworker) + +_This split is pretty arbitrary and doesn't necessarily reflect how you would normally separate services into different repositories._ + +## Usage + +This project doesn't require any setup and can be deployed right away. If this is your first time working with this project, Garden will start by fetching the remote source code: +```sh +garden deploy +``` +Garden will continue to use the version originally downloaded. Use the `update-remote sources|modules|all` command to fetch the latest version of your remote sources and modules: +```sh +garden update-remote modules jworker +``` +If you however change the repository URL of your remote source or module (e.g. switch to a different tag or branch), Garden will automatically fetch the correct version. + +It's also possible to link remote sources and modules to a local directory with the `link source|module` command. This is useful for when you want to try out changes to the remote source without having to push them to the remote repository. In this case, you clone the remote source to a local directory and link to its path: +```sh +garden link source web-services path/to/web-services +``` +Now Garden will read the module from its local path, and changes you make will be visible immediately. + +Use the `unlink source|module` command to unlink it again, and revert to the module version the repository URL points to: +```sh +garden unlink source web-services +``` + +## Further reading + +### Project structure + +Looking at the project structure, you'll notice that the project doesn't contain any code outside the `garden.yml` config files. Rather, the config files themselves contain the URLs to the remote repositories. + +```sh +$ tree +. +├── README.md +├── garden.yml +└── services + └── jworker + └── garden.yml + +2 directories, 3 files +``` + +### Configuring remote sources + +For this project, we want to import the database and web services as remote _sources_. This means that the entire source code gets embedded into the project and treated just like our other project files. As usual, Garden will scan the project for `garden.yml` files, and include all modules it finds. + +To import remote sources, we add them under the `sources` key in the top-level project configuration file: + +```yaml +project: + name: remote-sources + sources: + - name: web-services + repositoryUrl: https://github.com/garden-io/garden-example-remote-sources-web-services.git#v0.1.0 + - name: db-services + repositoryUrl: https://github.com/garden-io/garden-example-remote-sources-db-services.git#v0.1.0 +``` + +> Remote repository URLs must contain a hash part that references a specific branch or tag, e.g. `https://github.com/org/repo.git/#my-tag-or-branch`. The remote repositories used in this example all contain the tag `v0.1.0`. Read more about Git tagging [here](https://git-scm.com/book/en/v2/Git-Basics-Tagging). + +### Configuring remote modules + +Additionally, we want to import the Java worker as a remote _module_. In that case, Garden assumes that the remote repository contains the source code for a single Garden module. Furthermore, the `garden.yml` config file for that module is kept in the main project repo: +```sh +$ tree services +services +└── jworker + └── garden.yml + +1 directory, 1 file +``` +and the path to the repository URL is added under the `repositoryUrl` key like so: +```yaml +module: + description: worker + type: container + name: jworker + repositoryUrl: https://github.com/garden-io/garden-example-remote-module-jworker.git#v0.1.0 + services: + - name: javaworker + dependencies: + - redis +``` + +Note that a project can contain its own modules and also import remote sources and modules. \ No newline at end of file diff --git a/docs/examples/simple-project.md b/docs/examples/simple-project.md index 60b9842968c..cf004291f8e 100644 --- a/docs/examples/simple-project.md +++ b/docs/examples/simple-project.md @@ -1,6 +1,6 @@ # Simple Project -In this guide, we'll walk you through configuring a simple project to run on the Garden framework. The project will consist of two Dockerized web services that communicate with one another, along with unit and integration tests. +In this guide, we'll walk you through configuring a simple project to run on Garden. The project will consist of two Dockerized web services that communicate with one another, along with unit and integration tests. In what follows you'll learn how to: @@ -13,23 +13,23 @@ In what follows you'll learn how to: ## Before you get started -This tutorial assumes that you have already have a running [installation of Garden](../introduction/getting-started.md). +This tutorial assumes that you have already have a running [installation of Garden](../basics/installation.md). ## Clone the example repo -The code for this tutorial can be found in our Github repository under the [examples directory](https://github.com/garden-io/garden/tree/master/examples). We'll use the [simple-project-start](https://github.com/garden-io/garden/tree/master/examples/simple-project-start/) example and work our way from there. The complete version is under [simple-project](https://github.com/garden-io/garden/tree/master/examples/simple-project). +The code for this tutorial can be found in our Github repository under the [examples directory](https://github.com/garden-io/garden/tree/master/examples). We'll use the [simple-project-start](https://github.com/garden-io/garden/tree/master/examples/simple-project-start/) example and work our way from there. The final version is under [simple-project](https://github.com/garden-io/garden/tree/master/examples/simple-project). First, let's clone the examples repo, change into the directory, and take a look inside: ```sh -$ git clone https://github.com/garden-io/garden/examples.git +$ git clone https://github.com/garden-io/garden.git $ cd garden/examples/simple-project-start $ tree . . └── services ├── go-service - │   ├── Dockerfile - │   └── webserver - │   └── main.go + │ ├── Dockerfile + │ └── webserver + │ └── main.go └── node-service ├── Dockerfile ├── app.js @@ -41,13 +41,13 @@ $ tree . 5 directories, 7 files ``` -As you can see the project consists of two super simple services and their accompanying Dockerfiles. One of the core tenets of multi-service backends is being able to pick the right tool for the job, and therefore we have a Node.js service and a Golang service, that we can pretend have different responsibilities. +As you can see, the project consists of two super simple services and their accompanying Dockerfiles. One of the core tenets of multi-service backends is being able to pick the right tool for the job, and therefore we have a Node.js service and a Go service, that we can pretend have different responsibilities. The task at hand is to configure these services so that they can run on the Garden framework. ## Project-wide configuration -To begin with, every project needs a project-wide `garden.yml` [configuration file](../guides/configuration.md#Config) at the root level. There we define, among other things, the name of the project, and the [providers](../guides/glossary.md#Provider) used for each [plugin](../guides/glossary.md#Plugin) the project requires. +To begin with, every project needs a project-wide `garden.yml` [configuration file](../using-garden/configuration-files.md) at the root level. There we define, among other things, the name of the project, and the [providers](../reference/glossary.md#Provider) the project requires. Let's go ahead and create one: @@ -66,11 +66,11 @@ project: - name: local-kubernetes ``` -Above, we've specified the name of our project and configured it to use the local-kubernetes plugin for local development. Note, that this file must be located in the project root directory. +Above, we've specified the name of our project and configured it to use the local-kubernetes provider for local development. Note that this file must be located in the project root directory. ## Module configuration -Now, let's turn to our services. Services live inside [modules](../guides/glossary.md#Module), and each module has it's own `garden.yml` configuration file. +Now, let's turn to our services. Services live inside [modules](../reference/glossary.md#Module), and each module has it's own `garden.yml` configuration file. We'll start with the module for the `node-service`: @@ -92,7 +92,7 @@ By running the `scan` command we can see that Garden detects our module config: $ garden scan - name: node-service type: container - path: /Users/eysi/code/simple-project/services/node-service + path: /Users/username/code/simple-project/services/node-service description: Node service container version: versionString: 2c8818986d-1528373640 @@ -112,18 +112,19 @@ module: ports: - name: http containerPort: 8080 - endpoints: + ingresses: - path: /hello-node port: http ``` -The [services](../guides/configuration.md#Services) directive is specific to container modules, and defines the services exposed by the module. In this case, our containerized Node.js server. The sub-directives tell Garden how to start the service and which endpoints to expose. +The [services](../using-garden/configuration-files.md#Services) directive is specific to container modules, and defines the services exposed by the module. In this case, our containerized Node.js server. The sub-directives tell Garden how to start the service and which ingress endpoints to expose. ## Deploying -With this configuration we're almost ready to deploy. First, we'll need to create a user namespace for our environment with the login command: +With this configuration we're almost ready to deploy. First, we'll need to make sure the environment is ready, by +running the init command: ```sh -$ garden login +$ garden init ``` Garden can now deploy our service to a local Kubernetes cluster: @@ -132,7 +133,7 @@ Garden can now deploy our service to a local Kubernetes cluster: $ garden deploy ``` -To verify that everything is working, we can call the service at the `/hello-node` endpoint defined in `/services/node-service/app.js`: +To verify that everything is working, we can call the service at the `/hello-node` ingress defined in `/services/node-service/app.js`: ```sh $ garden call node-service/hello-node @@ -143,7 +144,7 @@ $ garden call node-service/hello-node Hello from Node server! ``` -In a similar manner, we create a config file for our `go-service`: +In a similar manner, we create a config file for our `go-service` with ```sh $ touch services/go-service/garden.yml @@ -160,7 +161,7 @@ module: ports: - name: http containerPort: 80 - endpoints: + ingresses: - path: /hello-go port: http ``` @@ -187,7 +188,7 @@ Looks good! Let's take stock: ## Inter-service communication -Calling our `go-service` from our `node-service` is straightforward from within the application code. Crack open `services/node-service/app.js` with your favorite editor and add the following: +Calling the `go-service` from the `node-service` is straightforward from within the application code. Open `services/node-service/app.js` with your favorite editor and add the following: ```javascript const request = require('request-promise') @@ -290,7 +291,7 @@ module: ports: - name: http containerPort: 8080 - endpoints: + ingresses: - path: / port: http dependencies: @@ -306,4 +307,4 @@ module: And that's it! Our services are up and running locally, dependencies are resolved, and tests are ready to run. -Check out some of our other [Guides](../guides/README.md) for more of an in-depth look at the Garden framework. \ No newline at end of file +Check out some of our other [Example projects](./examples/README.md) for more of an in-depth look. \ No newline at end of file diff --git a/docs/examples/tls-project.md b/docs/examples/tls-project.md new file mode 100644 index 00000000000..610c7f985a8 --- /dev/null +++ b/docs/examples/tls-project.md @@ -0,0 +1,58 @@ +# Local TLS example project + +This project shows how you can configure a TLS certificate to use for local development on Kubernetes. + +For the example to work you need to configure a local certificate authority (CA) on your computer for development. We'll use +[mkcert](https://github.com/FiloSottile/mkcert) for this purpose. + +## Setup + +### Step 1 - Install mkcert + +If you don't have mkcert installed, follow the instructions [here](https://github.com/FiloSottile/mkcert#installation). + +### Step 2 - Generate a certificate + +After you've run `mkcert -install`, run + +```sh +mkcert garden.dev '*.garden.dev' +``` + +_Note: You may choose another hostname if you prefer, but you'll need to update the project `garden.yml` accordingly._ + +### Step 3 - Configure the certificate in your Kubernetes installation + +Create a Kubernetes Secret with your generated certificate and key. + +```sh +kubectl create secret tls tls-garden-dev --key garden.dev+1-key.pem --cert garden.dev+1.pem +``` + +_The filenames above will be different if you used a different hostname._ + +### Step 4 - Configure the hostname in your hosts file + +Add the `garden.dev` hostname to the hosts file on your machine, and have it point to the IP of your local cluster. +If you use Docker for Desktop, the IP will be `127.0.0.1`. If you use minikube, you can get the IP by running +`minikube ip`. + +We recommend using the [hosts](https://github.com/alphabetum/hosts) tool (or something similar) to modify your hosts +file, but you may also edit it directly (it's at `/etc/hosts` on most platforms). + +## Usage + +Once you've completed the above, you can deploy the example project and the exposed ingress endpoints will be +secured with TLS! + +Deploy the project: + +```sh +garden deploy +``` + +And then try sending a simple request using: + +```sh +garden call node-service/hello +``` \ No newline at end of file diff --git a/docs/introduction/getting-started.md b/docs/introduction/getting-started.md deleted file mode 100644 index e583d55819a..00000000000 --- a/docs/introduction/getting-started.md +++ /dev/null @@ -1,162 +0,0 @@ -# Getting Started - -This guide will walk you through setting up the Garden framework. - -## Installation - -### macOS - -For Mac, we recommend the following steps to install Garden. You can also follow the manual installation -steps below if you prefer. - -#### Step 1: Install homebrew - -If you haven't already set up homebrew, please follow [their instructions](https://brew.sh/) to set it up. - -#### Step 2: Docker and local Kubernetes - -To install Docker, Kubernetes and kubectl, we strongly recommend Docker for Mac (edge version). - -_Note: you need to install the **edge version** of Docker for Mac in -order to enable Kubernetes support._ - -Once installed, open the Docker for Mac preferences, go to the Kubernetes section, -tick `Enable Kubernetes` and save. Please refer to their -[installation guide](https://docs.docker.com/engine/installation/) for details. - -Alternatively, you can use Minikube. We generally find it less stable and more hassle to -configure and use, but we do fully support it on Mac if you have it running. Please look at our -[Minikube guide](../guides/minikube.md) for details. - -#### Step 3: Install `garden-cli` - -We have a Homebrew tap and package that you can use to easily install `garden-cli` and all dependencies: - -```sh -brew tap garden-io/garden -brew install garden-cli -``` - -To later upgrade to the newest version, simply run `brew update` and then `brew upgrade garden-cli` -(or `brew upgrade` to upgrade all your Homebrew packages). - -### Windows - -You can run garden on Windows 10 Pro or Enterprise editions. Follow these instructions to get started. - -#### Step 1: Chocolatey - -If you haven't already, install the [Chocolatey](https://chocolatey.org) package manager. - -#### Step 2: Enable Hyper-V - -This is required for _Docker for Windows_ to run. Open PowerShell as an administrator and run: - -```powershell -Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V -All -``` - -This will require a restart. - -#### Step 3: Docker for Windows - -Install the Edge version of [Docker for Windows](https://www.docker.com/docker-windows). - -Once installed, open the Docker for Windows settings, go to the Kubernetes section, -tick `Enable Kubernetes` and save. Please refer to their -[installation guide](https://docs.docker.com/engine/installation/) for details. - -#### Step 4: Install dependencies - -Open PowerShell as an administrator and run: - -```powershell -# install choco packages (note: python is needed to build some dependencies) -choco install -y git nodejs rsync kubernetes-helm - -# install Stern (currently not available as a choco package) -[Net.ServicePointManager]::SecurityProtocol = "tls12, tls11, tls" -Invoke-WebRequest -Uri "https://github.com/wercker/stern/releases/download/1.7.0/stern_windows_amd64.exe" -OutFile "$Env:SystemRoot\system32\stern.exe" - -# install build tools so that node-gyp works -npm install --global --production windows-build-tools -npm config set msvs_version 2015 --global -``` - -#### Step 5: Install `garden-cli` - -Once you have the dependencies set up, open a new PowerShell and install the Garden CLI via `npm`: - -```powershell -npm install -g garden-cli -``` - -To later upgrade to the newest version, run `npm install -g -U garden-cli`. - -### Linux / manual installation - -You need the following dependencies on your local machine to use Garden: - -* Node.js >= 8.x -* [Docker](https://docs.docker.com/) -* Git -* rsync -* [Helm](https://github.com/kubernetes/helm) -* Local installation of Kubernetes and kubectl - -#### Step 1: Docker - -To install Docker, please follow the instructions in the [official documentation](https://docs.docker.com/install/). - -#### Step 2: Local Kubernetes - -For local Kubernetes, you can use [Minikube](https://github.com/kubernetes/minikube). Please see our -[Minikube guide](../guides/minikube.md) for instructions. - -#### Step 3: Install other dependencies - -Use your preferred method or package manager to install `node` (version 8.x or higher), `git`, `rsync` and -[Helm](https://github.com/kubernetes/helm). - -#### Step 4: Install `garden-cli` - -Once you have the dependencies set up, install the Garden CLI via `npm`: - -```sh -npm install -g garden-cli -``` - -To later upgrade to the newest version, run `npm install -g -U garden-cli`. - -## Using the CLI - -With the CLI installed, we can now try out a few commands using the [hello-world](https://github.com/garden-io/garden/examples/tree/master/simple-project) project from our Github [examples repository](https://github.com/garden-io/garden/examples). The example consists of a a couple of simple services. - -_Note: check if Kubernetes is running with `kubectl version`. You should see both a `Client Version` and a `Server Version` in the response. If not, please start it up before proceeding._ - -Clone the repo and change into the `hello-world` directory: - -```sh -$ git clone https://github.com/garden-io/garden/examples.git -$ cd garden/examples/hello-world -``` - -First, let's check the environment status by running the following from the project root: - -```sh -$ garden status -``` - -The response tells us how the environment is configured and the status of the providers. Next, we'll deploy the services with: - -```sh -$ garden deploy -``` - -And that's it! The services are now running on the Garden framework. You can see for yourself by querying the `/hello` endpoint of the container with: - -```sh -$ garden call hello-container/hello -``` - -Check out our [Commands guide](../guides/commands.md) for other features like auto-reload, streaming service logs, running tests and lots more, or see how a Garden project is configured from scratch in our [Simple Project](../guides/simple-project.md) guide. diff --git a/docs/outline.md b/docs/outline.md new file mode 100644 index 00000000000..01e5899aef0 --- /dev/null +++ b/docs/outline.md @@ -0,0 +1,164 @@ +# DELETE THIS FILE ONCE NEW DOCS ARE COMPLETE + +# README + +- Logo +- Status +- Features +- Usage +- Contributing +- Motivation +- Acknowledgements + +# Basics + +- Chapter outline + +## Installation + +- Intro +- macOS +- Windows +- Linux (manual installation) +- Minikube Instructions + +## Quick Start + +- Using the CLI + - garden get status + - garden build + - garden deploy + - garden test + - garden dev + - garden call + +## Concepts + +- How Garden works +- Projects vs. modules vs. services +- The build → test → deploy sequence +- How inter-service communication works +- An overview of the providers system +- Hot reload +- Projects with multiple and/or remote repositories + +# Using Garden + + +## Features and usage + +- File watching, building, and deploying +- Testing +- Hot reload +- TLS +- Remote Clusters +- Multiple/remote repos + +## Configuration files + +- Introduction +- Project configs +- Module configs +- Services +- Tests + +## Providers + +- How providers work +- What's expected of providers +- Provider actions + +# Example projects + + +## Hello world + + +## Simple project + + +## TLS project + + +## Socks shop or Coolstore set-up + + +## Something heavy on serverless + + +# Guides + + +## Projects with multiple remote and local repos + + +## Configuring hot reload + + +## Setting up TLS + + +## How to "gardenify" an existing project + + +## Migration guide from Docker Compose to Garden + + +## Getting started with Kubernetes using the Garden framework + + +# Contributing to Garden + + +# Reference + + +## Glossary + +- When you get here to through the relevant places in the docs and add links to the definitions. + + +## Commands Reference + + +## Config Files Reference + + +## Provider Configurations + + +### Container + + +### Kubernetes + + +### OpenFaaS + + +### Local Kubernetes + + +### Google Cloud Functions + + +## Module Configurations + + +### Container + + +### Kubernetes + + +### OpenFaaS + + +### Local Kubernetes + + +### Google Cloud Functions + + +# FAQs + diff --git a/docs/reference/README.md b/docs/reference/README.md index aa067ae31dc..f4caf28db90 100644 --- a/docs/reference/README.md +++ b/docs/reference/README.md @@ -1,5 +1,5 @@ # Reference -* [Commands](./commands.md) -* [Config](./config.md) -* [Template strings](./template-strings.md) +* [Glossary](./glossary.md) +* [Commands Reference](./command-reference.md) +* [Config Files Reference](./config-files-reference.md) diff --git a/docs/reference/command-reference.md b/docs/reference/command-reference.md new file mode 100644 index 00000000000..e3c4fde7668 --- /dev/null +++ b/docs/reference/command-reference.md @@ -0,0 +1,716 @@ +## Garden CLI commands + +Below is a list of Garden CLI commands and usage information. + +The commands should be run in a Garden project root, and are always scoped to that project. + +Note: You can get a list of commands in the CLI by running `garden -h/--help`, +and detailed help for each command using `garden -h/--help` + +##### Global options + +The following option flags can be used with any of the CLI commands: + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--root` | `-r` | string | Override project root directory (defaults to working directory). + | `--silent` | `-s` | boolean | Suppress log output. + | `--env` | `-e` | string | The environment (and optionally namespace) to work against + | `--loglevel` | `-l` | `error` `warn` `info` `verbose` `debug` `silly` `0` `1` `2` `3` `4` `5` | Set logger level. Values can be either string or numeric and are prioritized from 0 to 5 (highest to lowest) as follows: error: 0, warn: 1, info: 2, verbose: 3, debug: 4, silly: 5 + | `--output` | `-o` | `json` `yaml` | Output command result in specified format (note: disables progress logging). + +### garden build + +Build your modules. + +Builds all or specified modules, taking into account build dependency order. +Optionally stays running and automatically builds modules if their source (or their dependencies' sources) change. + +Examples: + + garden build # build all modules in the project + garden build my-module # only build my-module + garden build --force # force rebuild of modules + garden build --watch # watch for changes to code + +##### Usage + + garden build [module] [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `module` | No | Specify module(s) to build. Use comma separator to specify multiple modules. + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--force` | | boolean | Force rebuild of module(s). + | `--watch` | `-w` | boolean | Watch for changes in module(s) and auto-build. + +### garden call + +Call a service ingress endpoint. + +This command resolves the deployed ingress endpoint for the given service and path, calls the given endpoint and +outputs the result. + +Examples: + + garden call my-container + garden call my-container/some-path + +Note: Currently only supports simple GET requests for HTTP/HTTPS ingresses. + +##### Usage + + garden call + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `serviceAndPath` | Yes | The name of the service(s) to call followed by the ingress path (e.g. my-container/somepath). + +### garden create project + +Creates a new Garden project. + +The 'create project' command walks the user through setting up a new Garden project and +generates scaffolding based on user input. + +Examples: + + garden create project # creates a new Garden project in the current directory (project name defaults to + directory name) + garden create project my-project # creates a new Garden project in my-project directory + garden create project --module-dirs=path/to/modules1,path/to/modules2 + # creates a new Garden project and looks for pre-existing modules in the modules1 and modules2 directories + garden create project --name my-project + # creates a new Garden project in the current directory and names it my-project + +##### Usage + + garden create project [project-dir] [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `project-dir` | No | Directory of the project. (Defaults to current directory.) + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--module-dirs` | | array:path | Relative path to modules directory. Use comma as a separator to specify multiple directories + | `--name` | | string | Assigns a custom name to the project. (Defaults to name of the current directory.) + +### garden create module + +Creates a new Garden module. + +Creates a new Garden module of the given type + +Examples: + + garden create module # creates a new module in the current directory (module name defaults to directory name) + garden create module my-module # creates a new module in my-module directory + garden create module --type=container # creates a new container module + garden create module --name=my-module # creates a new module in current directory and names it my-module + +##### Usage + + garden create module [module-dir] [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `module-dir` | No | Directory of the module. (Defaults to current directory.) + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--name` | | string | Assigns a custom name to the module. (Defaults to name of the current directory.) + | `--type` | | `container` `google-cloud-function` `npm-package` | Type of module. + +### garden delete secret + +Delete a secret from the environment. + +Returns with an error if the provided key could not be found by the provider. + +Examples: + + garden delete secret kubernetes somekey + garden del secret local-kubernetes some-other-key + +##### Usage + + garden delete secret + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `provider` | Yes | The name of the provider to remove the secret from. + | `key` | Yes | The key of the configuration variable. Separate with dots to get a nested key (e.g. key.nested). + +### garden delete environment + +Deletes a running environment. + +This will trigger providers to clear up any deployments in a Garden environment and reset it. +When you then run `garden init`, the environment will be reconfigured. + +This can be useful if you find the environment to be in an inconsistent state, or need/want to free up +resources. + +##### Usage + + garden delete environment + +### garden delete service + +Deletes a running service. + +Deletes (i.e. un-deploys) the specified services. Note that this command does not take into account any +services depending on the deleted service, and might therefore leave the project in an unstable state. +Running `garden deploy` will re-deploy any missing services. + +Examples: + + garden delete service my-service # deletes my-service + +##### Usage + + garden delete service + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `service` | Yes | The name of the service(s) to delete. Use comma as separator to specify multiple services. + +### garden deploy + +Deploy service(s) to your environment. + + + Deploys all or specified services, taking into account service dependency order. + Also builds modules and dependencies if needed. + + Optionally stays running and automatically re-builds and re-deploys services if their module source + (or their dependencies' sources) change. + + Examples: + + garden deploy # deploy all modules in the project + garden deploy my-service # only deploy my-service + garden deploy --force # force re-deploy of modules, even if they're already deployed + garden deploy --watch # watch for changes to code + garden deploy --env stage # deploy your services to an environment called stage + + +##### Usage + + garden deploy [service] [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `service` | No | The name of the service(s) to deploy (skip to deploy all services). Use comma as separator to specify multiple services. + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--force` | | boolean | Force redeploy of service(s). + | `--force-build` | | boolean | Force rebuild of module(s). + | `--watch` | `-w` | boolean | Watch for changes in module(s) and auto-deploy. + +### garden dev + +Starts the garden development console. + + + The Garden dev console is a combination of the `build`, `deploy` and `test` commands. + It builds, deploys and tests all your modules and services, and re-builds, re-deploys and re-tests + as you modify the code. + + Examples: + + garden dev + + +##### Usage + + garden dev + +### garden exec + +Executes a command (such as an interactive shell) in a running service. + +Finds an active container for a deployed service and executes the given command within the container. +Supports interactive shells. + +_NOTE: This command may not be supported for all module types._ + +Examples: + + garden exec my-service /bin/sh # runs a shell in the my-service container + +##### Usage + + garden exec + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `service` | Yes | The service to exec the command in. + | `command` | Yes | The command to run. + +### garden get secret + +Get a secret from the environment. + +Returns with an error if the provided key could not be found. + +Examples: + + garden get secret kubernetes somekey + garden get secret local-kubernetes some-other-key + +##### Usage + + garden get secret + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `provider` | Yes | The name of the provider to read the secret from. + | `key` | Yes | The key of the configuration variable. + +### garden get status + +Outputs the status of your environment. + + +##### Usage + + garden get status + +### garden init + +Initialize system, environment or other runtime components. + +This command needs to be run before first deploying a Garden project, and occasionally after updating Garden, +plugins or project configuration. + +Examples: + + garden init + garden init --force # runs the init flows even if status checks report that the environment is ready + +##### Usage + + garden init [options] + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--force` | | boolean | Force initalization of environment, ignoring the environment status check. + +### garden link source + +Link a remote source to a local directory. + +After linking a remote source, Garden will read it from its local directory instead of +from the remote URL. Garden can only link remote sources that have been declared in the project +level garden.yml config. + +Examples: + + garden link source my-source path/to/my-source # links my-source to its local version at the given path + +##### Usage + + garden link source + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `source` | Yes | Name of the source to link as declared in the project config. + | `path` | Yes | Path to the local directory that containes the source. + +### garden link module + +Link a module to a local directory. + +After linking a remote module, Garden will read the source from the module's local directory instead of from +the remote URL. Garden can only link modules that have a remote source, +i.e. modules that specifiy a repositoryUrl in their garden.yml config file. + +Examples: + + garden link module my-module path/to/my-module # links my-module to its local version at the given path + +##### Usage + + garden link module + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `module` | Yes | Name of the module to link. + | `path` | Yes | Path to the local directory that containes the module. + +### garden logs + +Retrieves the most recent logs for the specified service(s). + +Outputs logs for all or specified services, and optionally waits for news logs to come in. + +Examples: + + garden logs # prints latest logs from all services + garden logs my-service # prints latest logs for my-service + garden logs -t # keeps running and streams all incoming logs to the console + +##### Usage + + garden logs [service] [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `service` | No | The name of the service(s) to logs (skip to logs all services). Use comma as separator to specify multiple services. + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--tail` | `-t` | boolean | Continuously stream new logs from the service(s). + +### garden publish + +Build and publish module(s) to a remote registry. + +Publishes built module artifacts for all or specified modules. +Also builds modules and dependencies if needed. + +Examples: + + garden publish # publish artifacts for all modules in the project + garden publish my-container # only publish my-container + garden publish --force-build # force re-build of modules before publishing artifacts + garden publish --allow-dirty # allow publishing dirty builds (which by default triggers error) + +##### Usage + + garden publish [module] [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `module` | No | The name of the module(s) to publish (skip to publish all modules). Use comma as separator to specify multiple modules. + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--force-build` | | boolean | Force rebuild of module(s) before publishing. + | `--allow-dirty` | | boolean | Allow publishing dirty builds (with untracked/uncommitted changes). + +### garden run module + +Run an ad-hoc instance of a module. + +This is useful for debugging or ad-hoc experimentation with modules. + +Examples: + + garden run module my-container # run an ad-hoc instance of a my-container container and attach to it + garden run module my-container /bin/sh # run an interactive shell in a new my-container container + garden run module my-container --i=false /some/script # execute a script in my-container and return the output + +##### Usage + + garden run module [command] [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `module` | Yes | The name of the module to run. + | `command` | No | The command to run in the module. + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--interactive` | | boolean | Set to false to skip interactive mode and just output the command result. + | `--force-build` | | boolean | Force rebuild of module before running. + +### garden run service + +Run an ad-hoc instance of the specified service + +This can be useful for debugging or ad-hoc experimentation with services. + +Examples: + + garden run service my-service # run an ad-hoc instance of a my-service and attach to it + +##### Usage + + garden run service [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `service` | Yes | The service to run + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--force-build` | | boolean | Force rebuild of module + +### garden run test + +Run the specified module test. + +This can be useful for debugging tests, particularly integration/end-to-end tests. + +Examples: + + garden run test my-module integ # run the test named 'integ' in my-module + garden run test my-module integ --i=false # do not attach to the test run, just output results when completed + +##### Usage + + garden run test [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `module` | Yes | The name of the module to run. + | `test` | Yes | The name of the test to run in the module. + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--interactive` | | boolean | Set to false to skip interactive mode and just output the command result. + | `--force-build` | | boolean | Force rebuild of module before running. + +### garden scan + +Scans your project and outputs an overview of all modules. + + +##### Usage + + garden scan + +### garden set secret + +Set a secret value for a provider in an environment. + +These secrets are handled by each provider, and may for example be exposed as environment +variables for services or mounted as files, depending on how the provider is implemented +and configured. + +_Note: The value is currently always stored as a string._ + +Examples: + + garden set secret kubernetes somekey myvalue + garden set secret local-kubernets somekey myvalue + +##### Usage + + garden set secret + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `provider` | Yes | The name of the provider to store the secret with. + | `key` | Yes | A unique identifier for the secret. + | `value` | Yes | The value of the secret. + +### garden test + +Test all or specified modules. + + + Runs all or specified tests defined in the project. Also builds modules and dependencies, + and deploy service dependencies if needed. + + Optionally stays running and automatically re-runs tests if their module source + (or their dependencies' sources) change. + + Examples: + + garden test # run all tests in the project + garden test my-module # run all tests in the my-module module + garden test -n integ # run all tests with the name 'integ' in the project + garden test --force # force tests to be re-run, even if they're already run successfully + garden test --watch # watch for changes to code + + +##### Usage + + garden test [module] [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `module` | No | The name of the module(s) to deploy (skip to test all modules). Use comma as separator to specify multiple modules. + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--name` | `-n` | string | Only run tests with the specfied name (e.g. unit or integ). + | `--force` | `-f` | boolean | Force re-test of module(s). + | `--force-build` | | boolean | Force rebuild of module(s). + | `--watch` | `-w` | boolean | Watch for changes in module(s) and auto-test. + +### garden unlink source + +Unlink a previously linked remote source from its local directory. + +After unlinking a remote source, Garden will go back to reading it from its remote URL instead +of its local directory. + +Examples: + + garden unlink source my-source # unlinks my-source + garden unlink source --all # unlinks all sources + +##### Usage + + garden unlink source [source] [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `source` | No | Name of the source(s) to unlink. Use comma separator to specify multiple sources. + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--all` | `-a` | boolean | Unlink all sources. + +### garden unlink module + +Unlink a previously linked remote module from its local directory. + +After unlinking a remote module, Garden will go back to reading the module's source from +its remote URL instead of its local directory. + +Examples: + + garden unlink module my-module # unlinks my-module + garden unlink module --all # unlink all modules + +##### Usage + + garden unlink module [module] [options] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `module` | No | Name of the module(s) to unlink. Use comma separator to specify multiple modules. + +##### Options + +| Argument | Alias | Type | Description | +| -------- | ----- | ---- | ----------- | + | `--all` | `-a` | boolean | Unlink all modules. + +### garden update-remote sources + +Update remote sources. + +Update the remote sources declared in the project config. + +Examples: + + garden update-remote sources # update all remote sources in the project config + garden update-remote sources my-source # update remote source my-source + +##### Usage + + garden update-remote sources [source] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `source` | No | Name of the remote source(s) to update. Use comma separator to specify multiple sources. + +### garden update-remote modules + +Update remote modules. + +Remote modules are modules that have a repositoryUrl field +in their garden.yml config that points to a remote repository. + +Examples: + + garden update-remote modules # update all remote modules in the project + garden update-remote modules my-module # update remote module my-module + +##### Usage + + garden update-remote modules [module] + +##### Arguments + +| Argument | Required | Description | +| -------- | -------- | ----------- | + | `module` | No | Name of the remote module(s) to update. Use comma separator to specify multiple modules. + +### garden update-remote all + +Update all remote sources and modules. + +Examples: + + garden update-remote all # update all remote sources and modules in the project + +##### Usage + + garden update-remote all + +### garden validate + +Check your garden configuration for errors. + +Throws an error and exits with code 1 if something's not right in your garden.yml files. + +##### Usage + + garden validate diff --git a/docs/reference/config-files-reference.md b/docs/reference/config-files-reference.md new file mode 100644 index 00000000000..d8404f87066 --- /dev/null +++ b/docs/reference/config-files-reference.md @@ -0,0 +1,645 @@ +## garden.yml reference + +Below is the full schema for the `garden.yml` configuration files. For an introduction, +please look at our [configuration guide](../guides/configuration.md). + +Note that individual module types, e.g. `container`, add additional configuration keys. The built-in module types +are listed in the [Built-in module types](#built-in-module-types) section. Please refer to those for more details +on module configuration. + +```yaml + +# The schema version of the config file (currently not used). +# +# Required. +# Allowed values: "0" +version: 0 + +# Configure a module whose sources are located in this directory. +# +# Optional. +module: + # The type of this module. + # + # Example: "container" + # + # Required. + type: + + # The name of this module. + # + # Example: "my-sweet-module" + # + # Required. + name: + + description: + + # A remote repository URL to fetch the module from. Garden will read the garden.yml config from + # the local module. Currently only supports git servers. + # + # Example: "# or + # git+https://github.com/organization/some-module.git#v2.0" + # + # Optional. + repositoryUrl: + + # Variables that this module can reference and expose as environment variables. + # + # Example: + # my-variable: some-value + # + # Optional. + variables: + {} + + # Set to false to disable pushing this module to remote registries. + # + # Optional. + allowPush: true + + # Specify how to build the module. Note that plugins may specify additional keys on this object. + # + # Optional. + build: + # The command to run inside the module directory to perform the build. + # + # Example: + # - npm + # - run + # - build + # + # Optional. + command: + - + + # A list of modules that must be built before this module is built. + # + # Example: + # - name: some-other-module-name + # + # Optional. + dependencies: + - # Module name to build ahead of this module + # + # Required. + name: + + # Specify one or more files or directories to copy from the built dependency to this + # module. + # + # Optional. + copy: + - # POSIX-style path or filename of the directory or file(s) to copy to the target. + # + # Required. + source: + + # POSIX-style path or filename to copy the directory or file(s) to (defaults to same + # as source path). + # + # Optional. + target: + +# The configuration for a Garden project. This should be specified in the garden.yml file in your +# project root. +# +# Optional. +project: + # The name of the project. + # + # Example: "my-sweet-project" + # + # Required. + name: + + # The default environment to use when calling commands without the `--env` parameter. + # + # Optional. + defaultEnvironment: + + # Default environment settings, that are inherited (but can be overridden) by each configured + # environment + # + # Example: + # providers: [] + # variables: {} + # + # Optional. + environmentDefaults: + # Specify the provider that should store configuration variables for this environment. Use + # this when you configure multiple providers that can manage configuration. + # + # Optional. + configurationHandler: + + # A list of providers that should be used for this environment, and their configuration. + # Please refer to individual plugins/providers for details on how to configure them. + # + # Optional. + providers: + - # The name of the provider plugin to configure. + # + # Example: "local-kubernetes" + # + # Required. + name: + + # A key/value map of variables that modules can reference when using this environment. + # + # Optional. + variables: + {} + + # A list of environments to configure for the project. + # + # Example: + # - name: local + # providers: + # - name: local-kubernetes + # variables: {} + # + # Optional. + environments: + - # Specify the provider that should store configuration variables for this environment. Use + # this when you configure multiple providers that can manage configuration. + # + # Optional. + configurationHandler: + + # A list of providers that should be used for this environment, and their configuration. + # Please refer to individual plugins/providers for details on how to configure them. + # + # Optional. + providers: + - # The name of the provider plugin to configure. + # + # Example: "local-kubernetes" + # + # Required. + name: + + # A key/value map of variables that modules can reference when using this environment. + # + # Optional. + variables: + {} + + # Valid RFC1035/RFC1123 (DNS) label (may contain lowercase letters, numbers and dashes, must + # start with a letter, and cannot end with a dash) and additionally cannot contain + # consecutive dashes or be longer than 63 characters. + # + # Required. + name: + + # A list of remote sources to import into project + # + # Optional. + sources: + - # The name of the source to import + # + # Required. + name: + + # A remote respository URL. Currently only supports git servers. Use hash notation (#) to + # point to a specific branch or tag + # + # Example: "# or + # git+https://github.com/organization/some-module.git#v2.0" + # + # Required. + repositoryUrl: +``` + +## Built-in module types + +### generic + +```yaml + +# The module specification for a generic module. +# +# Required. +module: + # The type of this module. + # + # Example: "container" + # + # Required. + type: + + # The name of this module. + # + # Example: "my-sweet-module" + # + # Required. + name: + + description: + + # A remote repository URL to fetch the module from. Garden will read the garden.yml config from + # the local module. Currently only supports git servers. + # + # Example: "# or + # git+https://github.com/organization/some-module.git#v2.0" + # + # Optional. + repositoryUrl: + + # Variables that this module can reference and expose as environment variables. + # + # Example: + # my-variable: some-value + # + # Optional. + variables: + {} + + # Set to false to disable pushing this module to remote registries. + # + # Optional. + allowPush: true + + # Specify how to build the module. Note that plugins may specify additional keys on this object. + # + # Optional. + build: + # The command to run inside the module directory to perform the build. + # + # Example: + # - npm + # - run + # - build + # + # Optional. + command: + - + + # A list of modules that must be built before this module is built. + # + # Example: + # - name: some-other-module-name + # + # Optional. + dependencies: + - # Module name to build ahead of this module + # + # Required. + name: + + # Specify one or more files or directories to copy from the built dependency to this + # module. + # + # Optional. + copy: + - # POSIX-style path or filename of the directory or file(s) to copy to the target. + # + # Required. + source: + + # POSIX-style path or filename to copy the directory or file(s) to (defaults to same + # as source path). + # + # Optional. + target: + + # Key/value map of environment variables. Keys must be valid POSIX environment variable names + # (must be uppercase, may not start with `GARDEN`) and values must be primitives. + # + # Optional. + env: + {} + + # A list of tests to run in the module. + # + # Optional. + tests: + # The test specification of a generic module. + # + # Optional. + - # The name of the test. + # + # Required. + name: + + # The names of services that must be running before the test is run. + # + # Optional. + dependencies: + - + + # Maximum duration (in seconds) of the test run. + # + # Optional. + timeout: null + + # The command to run in the module build context in order to test it. + # + # Optional. + command: + - + + # Key/value map of environment variables. Keys must be valid POSIX environment variable + # names (must be uppercase, may not start with `GARDEN`) and values must be primitives. + # + # Optional. + env: + {} +``` + +### container + +```yaml + +# Configuration for a container module. +# +# Required. +module: + # The type of this module. + # + # Example: "container" + # + # Required. + type: + + # The name of this module. + # + # Example: "my-sweet-module" + # + # Required. + name: + + description: + + # A remote repository URL to fetch the module from. Garden will read the garden.yml config from + # the local module. Currently only supports git servers. + # + # Example: "# or + # git+https://github.com/organization/some-module.git#v2.0" + # + # Optional. + repositoryUrl: + + # Variables that this module can reference and expose as environment variables. + # + # Example: + # my-variable: some-value + # + # Optional. + variables: + {} + + # Set to false to disable pushing this module to remote registries. + # + # Optional. + allowPush: true + + # Specify how to build the module. Note that plugins may specify additional keys on this object. + # + # Optional. + build: + # The command to run inside the module directory to perform the build. + # + # Example: + # - npm + # - run + # - build + # + # Optional. + command: + - + + # A list of modules that must be built before this module is built. + # + # Example: + # - name: some-other-module-name + # + # Optional. + dependencies: + - # Module name to build ahead of this module + # + # Required. + name: + + # Specify one or more files or directories to copy from the built dependency to this + # module. + # + # Optional. + copy: + - # POSIX-style path or filename of the directory or file(s) to copy to the target. + # + # Required. + source: + + # POSIX-style path or filename to copy the directory or file(s) to (defaults to same + # as source path). + # + # Optional. + target: + + # Specify build arguments when building the container image. + # + # Optional. + buildArgs: + {} + + # Specify the image name for the container. Should be a valid docker image identifier. If + # specified and the module does not contain a Dockerfile, this image will be used to deploy the + # container services. If specified and the module does contain a Dockerfile, this identifier is + # used when pushing the built image. + # + # Optional. + image: + + # List of services to deploy from this container module. + # + # Optional. + services: + # The required attributes of a service. This is generally further defined by plugins. + # + # Optional. + - # Valid RFC1035/RFC1123 (DNS) label (may contain lowercase letters, numbers and dashes, must + # start with a letter, and cannot end with a dash) and additionally cannot contain + # consecutive dashes or be longer than 63 characters. + # + # Required. + name: + + # The names of services that this service depends on at runtime. + # + # Optional. + dependencies: + # Valid RFC1035/RFC1123 (DNS) label (may contain lowercase letters, numbers and dashes, + # must start with a letter, and cannot end with a dash) and additionally cannot contain + # consecutive dashes or be longer than 63 characters. + # + # Optional. + - + + # Key/value map, keys must be valid identifiers. + # + # Optional. + outputs: + {} + + # The arguments to run the container with when starting the service. + # + # Optional. + command: + - + + # Whether to run the service as a daemon (to ensure only one runs per node). + # + # Optional. + daemon: false + + # List of endpoints that the service exposes. + # + # Example: + # - path: /api + # port: http + # + # Optional. + endpoints: + - # The hostname that should route to this service. Defaults to the default hostname + # configured + # in the provider configuration. + # + # Note that if you're developing locally you may need to add this hostname to your hosts + # file. + # + # Optional. + hostname: + + # The path which should be routed to the service. + # + # Optional. + path: / + + # The name of the container port where the specified paths should be routed. + # + # Required. + port: + + # Key/value map of environment variables. Keys must be valid POSIX environment variable + # names (must be uppercase, may not start with `GARDEN`) and values must be primitives. + # + # Optional. + env: + {} + + # Specify how the service's health should be checked after deploying. + # + # Optional. + healthCheck: + # Set this to check the service's health by making an HTTP request + # + # Optional. + httpGet: + # The path of the service's health check endpoint. + # + # Required. + path: + + # The name of the port where the service's health check endpoint should be available. + # + # Required. + port: + + scheme: HTTP + + # Set this to check the service's health by running a command in its container. + # + # Optional. + command: + - + + # Set this to check the service's health by checking if this TCP port is accepting + # connections. + # + # Optional. + tcpPort: + + # List of ports that the service container exposes. + # + # Optional. + ports: + # + # Required. + - # The name of the port (used when referencing the port elsewhere in the service + # configuration. + # + # Required. + name: + + # The protocol of the service container port. + # + # Optional. + protocol: TCP + + # The port number on the service container. + # + # Required. + containerPort: + + hostPort: + + # Set this to expose the service on the specified port on the host node (may not be + # supported by all providers). + # + # Optional. + nodePort: + + # List of volumes that should be mounted when deploying the container. + # + # Optional. + volumes: + - # The name of the allocated volume. + # + # Required. + name: + + # The path where the volume should be mounted in the container. + # + # Required. + containerPath: + + hostPath: + + # A list of tests to run in the module. + # + # Optional. + tests: + # The test specification of a generic module. + # + # Optional. + - # The name of the test. + # + # Required. + name: + + # The names of services that must be running before the test is run. + # + # Optional. + dependencies: + - + + # Maximum duration (in seconds) of the test run. + # + # Optional. + timeout: null + + # The command to run in the module build context in order to test it. + # + # Optional. + command: + - + + # Key/value map of environment variables. Keys must be valid POSIX environment variable + # names (must be uppercase, may not start with `GARDEN`) and values must be primitives. + # + # Optional. + env: + {} +``` + diff --git a/docs/reference/glossary.md b/docs/reference/glossary.md new file mode 100644 index 00000000000..bf9998f6593 --- /dev/null +++ b/docs/reference/glossary.md @@ -0,0 +1,46 @@ +# Glossary + +#### Environment +Represents the current configuration and status of any running services in the [project](#project), which may be +inspected and modified via the Garden CLI's `environment` command. + +Several named environment configurations may be defined (e.g. _dev_, _testing_, ...) in the [project's +`garden.yml`](../guides/configuration.md#project-configuration). + +#### Module +The basic unit of configuration in Garden. A module is defined by its +[`garden.yml` configuration file](../guides/configuration.md#module-configuration), located in the module's top-level +directory, +which +is a subdirectory of the [project](#project) repository's top-level directory. + +Each module has a [plugin](#plugin) type, and may define one or more [services](#service). + +Essentially, a project is organized into modules at the granularity of its *build* steps. A module's build step may +depend on one or more other modules, as specified in its `garden.yml`, in which case those modules will be built +first, and their build output made available to the requiring module's build step. + +#### Provider +A [module's](#module) plugin type defines its behavior when it is built, deployed, run and tested. Currently, +`container` is the only stable plugin type, but plugin types for serverless functions and for build-only use cases +(such as NPM modules) are under development. + +#### Project +The top-level unit of organization in Garden. A project consists of one or more [modules](#module), along with a +project-level [`garden.yml` configuration file](../guides/configuration.md#project-configuration). + +Garden CLI commands are run in the context of a project, and are aware of all its modules and services. + +Currently, Garden projects assume that all their modules are rooted in subdirectories of the same Git repository, with +the project-level `garden.yml` located in the repository's top-level directory. In a future release, this mono-repo +structure will be made optional. + +#### Provider +An implementation of a [plugin type](#plugin) (e.g. `local-kubernetes` for the `container` plugin). + +#### Service +The unit of deployment in Garden. Services are defined in their parent [module](#module)'s `garden.yml`, each +exposing [one or more endpoints](../guides/configuration.md#services). + +Services may depend on services defined in other modules, in which case those services will be deployed first, and +their deployment output made available to the requiring service's deploy step. diff --git a/docs/reference/module-configs/README.md b/docs/reference/module-configs/README.md new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/reference/module-configs/container.md b/docs/reference/module-configs/container.md new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/reference/module-configs/google-cloud-functions.md b/docs/reference/module-configs/google-cloud-functions.md new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/reference/module-configs/openfaas.md b/docs/reference/module-configs/openfaas.md new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/reference/provider-configs/README.md b/docs/reference/provider-configs/README.md new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/reference/provider-configs/container.md b/docs/reference/provider-configs/container.md new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/reference/provider-configs/google-cloud-functions.md b/docs/reference/provider-configs/google-cloud-functions.md new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/reference/provider-configs/kubernetes.md b/docs/reference/provider-configs/kubernetes.md new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/reference/provider-configs/local-kubernetes.md b/docs/reference/provider-configs/local-kubernetes.md new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/reference/provider-configs/openfaas.md b/docs/reference/provider-configs/openfaas.md new file mode 100644 index 00000000000..e69de29bb2d diff --git a/docs/schematic.jpg b/docs/schematic.jpg new file mode 100644 index 00000000000..6225628018d Binary files /dev/null and b/docs/schematic.jpg differ diff --git a/docs/toc.md b/docs/toc.md new file mode 100644 index 00000000000..05d69eecb28 --- /dev/null +++ b/docs/toc.md @@ -0,0 +1,22 @@ +# Table of Contents + +* [Table of Contents](./toc.md) +* [Basics](./basics/README.md) + * [Installation](./basics/installation.md) + * [Quick Start](./basics/quick-start.md) + * [Concepts](./basics/concepts.md) +* [Using Garden](./using-garden/README.md) + * [Features and usage](./using-garden/features-and-usage.md) + * [Configuration files](./using-garden/configuration-files.md) + * [Remote Clusters](./using-garden/remote-clusters.md) + * [Hot Reload](./using-garden/hot-reload.md) +* [Example projects](./examples/README.md) + * [Hello world](./examples/hello-world.md) + * [Simple project](./examples/simple-project.md) + * [TLS project](./examples/tls-project.md) + * [Remote sources project](./examples/remote-sources.md) +* [Reference](./reference/README.md) + * [Glossary](./reference/glossary.md) + * [Commands Reference](./reference/command-reference.md) + * [Config Files Reference](./reference/config-files-reference.md) +* [FAQs](./faqs.md) \ No newline at end of file diff --git a/docs/using-garden/README.md b/docs/using-garden/README.md new file mode 100644 index 00000000000..60640b4acab --- /dev/null +++ b/docs/using-garden/README.md @@ -0,0 +1,17 @@ +# Using Garden + +## [Features and usage](./features-and-usage.md) + +In this article we discuss how to start a new project with `garden create`, the basic development workflow, how Garden's providers work, and the basics of testing and dependencies. + +## [Configuration files](./configuration-files.md) + +This one is all about Garden's configuration files. The difference between project and module configs, some significant specific fields, setting up services, and a primer on tests. + +## [Remote Clusters](./remote-clusters.md) + +Most of the time we want to develop locally, with our project running in Minikube or Docker. If you'd like to use a remote cluster though, check out this guide. + +## [Hot Reload](./hot-reload.md) + +This article discusses how to use hot reload, so that you can update files on the fly, without losing state and without having to destroy and re-create your container. \ No newline at end of file diff --git a/docs/using-garden/configuration-files.md b/docs/using-garden/configuration-files.md new file mode 100644 index 00000000000..ad97f197e1a --- /dev/null +++ b/docs/using-garden/configuration-files.md @@ -0,0 +1,201 @@ +# Configuration + +Garden is configured via `garden.yml` configuration files. + +The [project-wide](#project-configuration) `garden.yml` file should be located in the top-level directory of the +project's Git repository. + +In addition, each of the project's [modules](../reference/glossary.md#module)' `garden.yml` should be located in that +module's top-level directory. + +To get started, create a `garden.yml` file in the top-level directory of your repository, and a `garden.yml` file +in the top-level directory of each of the modules you'd like to define for your project. + +To decide how to split your project up into modules, it's useful to consider what parts of it are built as a single +step, and what the dependency relationships are between your build steps. For example, each container and each +serverless function should be represented by its own module. + +Below, we'll be using examples from the +[Hello world](../examples/hello-world.md) example project, which touches +on many of the things you're likely to want to configure in a project. + +## Project Configuration + +We'll start by looking at the top-level [project configuration file](https://github.com/garden-io/garden/blob/master/examples/hello-world/garden.yml). + +```yaml +# examples/hello-world/garden.yml +project: + name: hello-world + environmentDefaults: + variables: + my-variable: hello-variable + environments: + - name: local + providers: + - name: local-kubernetes + - name: openfaas +``` + +The project-wide `garden.yml` defines the project's name, the default configuration used for each +[environment](../reference/glossary.md#environment) (via the `environmentDefaults` directive), and +environment-specific provider configuration. The above only configures a `local` environment, but you could add +further environments, such as a remote Kubernetes environment. + +Here, project-wide configuration variables can also be specified (global, and/or environment-specific). These are +then available for substitution in any string value in any module's `garden.yml`. + +For example, assuming the above project configuration, `"foo-${variables.my-variable}-bar"` would evaluate to +`"foo-hello-variable-bar"` when used as a string value in a module's `garden.yml`. + +## Module Configuration + +Below, we'll use the module configurations of `hello-function` and `hello-container` from the +[Hello world](../examples/hello-world.md) example project +as examples to illustrate some of the primary module-level configuration options. + +The following is a snippet from `hello-container`'s module config: + +```yaml +module: + name: hello-container + type: container + description: Hello world container service + ... + build: + dependencies: + - name: hello-npm-package + copy: + - source: "./" + target: libraries/hello-npm-package/ +``` + +The first lines you'll find in all module configurations, and describe the module at a high level. + +The second part, the `build` key, demonstrates how Garden can serve as a build framework, managing build dependencies +and even copying files between modules as they are built. + +Below is a run-down of the individual configuration keys, and what they represent: + +### name + +The module's name, used e.g. when referring to it from another module's configuration as a +build dependency, or when building specific modules with `garden build`. + +Note that module names must be unique within a given project. An error will be thrown in any Garden CLI command if two +modules use the same name. + +### type + +A [module](../reference/glossary.md#module)'s `type` specifies what kind of module this is, which will control how the +module's code gets built, tested, deployed, etc. The module types are defined by _providers_. The built-in providers +include `container` and `generic` (which basically provides a way to run commands locally). + +The example above is a `container` module, and the `hello-function` module is an `openfaas` module +(which is one of many ways to run functions-as-a-service on Kubernetes). + +In this particular project, the `container` module type is deployed by the `local-kubernetes` provider, and the +`openfaas` module is built and deployed by the corresponding `openfaas` provider. + +### build + +A module's build configuration is specified via the `build` directive, and the implementation of what `build` does varies depending on which provider is responsible for that module. + +Regardless of the implementation, a module's build command is executed +with its working directory set to a copy of the module's top-level directory, located at +`[project-root]/.garden/build/[module-name]`. This internal directory is referred to as the module's +[build directory](../reference/glossary.md#build-directory). + +The `.garden` directory should not be modified by users, since this may lead to unexpected errors when the Garden CLI +tools are used in the project. + +The `build.dependencies` subdirective lists the module's build dependencies, which need to be built ahead of this module. +`name` is the required module's name. In many cases you only need to declare the build dependency name. For example, +you simply need to build one container before another because it's used as a base image. + +In other cases, you may actually need files to be copied from one built module to another. +The `copy` key indicates what files/folders, if any, should be copied from the required module's build directory to the +module in question after the required module is built (`source`), and where they should be copied to (`target`). + +In the above example, we copy the entire contents of `hello-npm-package`'s build directory, after it has been built, +into the `libraries/hello-npm-package/` in the `hello-container` build directory, _before the container is built_. + +## Services + +A module may contain zero or more _services_. Services are deployed when running `garden deploy` or `garden dev` as +part of your runtime stack. + +How services are configured will depend on the module type. An `openfaas` module always contains a single service. A +`container` module can contain any number of services (or none at all, if it's just used as a base image, for example). + +The following is a snippet from `hello-container`'s module config: + +```yaml +module: + description: Hello world container service + type: container + services: + - name: hello-container + command: [npm, start] + ports: + - name: http + containerPort: 8080 + endpoints: + - path: /hello + port: http + healthCheck: + httpGet: + path: /_ah/health + port: http + dependencies: + - hello-function + ... +``` + +Here the `services` directive defines the services exposed by the module. We only have one service in this example, +but you may add another service, for example a background worker, that is started using a different +`command`. + +For more details on how to configure services in a `container` module, please refer to the +[Config Files Reference](../reference/config-files-reference.md). + +## Tests + +Each module can define one or more test suites. How these tests are specified, much like services, depends on the +individual module type. However the concepts are most often the same; you specify one or more test suites, how to +execute them, and in some cases which services need to be running for the tests to run successfully. + +For an example, here is another snippet from the `hello-container` module configuration: + +```yaml +module: + description: Hello world container service + type: container + ... + tests: + - name: unit + command: [npm, test] + - name: integ + command: [npm, run, integ] + dependencies: + - hello-function +``` + +Here we define two types of tests. First are unit tests, which can be run on their own without any dependencies. The +framework only needs to know which command to run, and the rest is handled by the module's code itself. + +The other test suite, `integ`, leverages the Garden framework's ability to manage runtime dependencies for tests. In +this case, the integ test suite needs the `hello-function` service to be running for the tests to execute. + +This allows you write tests that actually call out to other services, rather than having to mock or stub those services +in your tests. + +Tests can be run via `garden test`, as well as `garden dev`. + +## Next steps + +We highly recommend browsing through the [Example projects](../examples/README.md) to see different examples of how projects and modules can be configured. + +Also be sure to look at the [Config Files Reference](../reference/config-files-reference.md) + for more details on each of the available +configuration keys. diff --git a/docs/using-garden/features-and-usage.md b/docs/using-garden/features-and-usage.md new file mode 100644 index 00000000000..23fe1a6b95e --- /dev/null +++ b/docs/using-garden/features-and-usage.md @@ -0,0 +1,109 @@ +# Features and Usage + +Now that you've had a glimpse at the basic Garden commands on the [Quick Start](./basics/quick-start.md) guide, and a brief look at the main [Concepts](../basics/concepts.md) we'll be dealing with, let's go through what the typical usage of Garden looks like. + +## Starting a new project + +For starting a new project with Garden there are two options: + +- You can create all the configuration files by hand, and for that you should take a look at our [Configuration files](./configuration-files.md) document. +- Or you can use the `garden create` command—a lot easier. + +### `garden create` + +The `garden create` command can be used to create either whole projects, or just modules. Essentially what it does is help you create configuration files so you don't have to do it by hand. + +The command `garden create project` will create a new project in the current directory and prompt you to add modules to it, which should each have a name and a type. It will then create the appropriate folders and the configuration files within them. + +If this is a pre-existing project and you want to "gardenify" code that's already there, you can try, for example, `garden create project --module-dirs=./services`. This will prompt you to create configuration files for every subfolder within the `./services` directory. + +To add individual modules later on you can use `garden create module`. + +``` +➜ test-project g create project + +Initializing new Garden project test-project +--------- +? Would you like to add a module to your project? Yes +? Enter module name my-module +? Module type container +? Add another module? (current modules: my-module) Yes +? Enter module name my-module-2 +? Module type container +? Add another module? (current modules: my-module, my-module-2) No +--------- +✔ Setting up project +✔ Writing config for my-module +✔ Writing config for my-module-2 +✔ Writing config for test-project +Project created! Be sure to check out our docs for how to get sarted! +``` + +For a practical example of "gardenifying" an existing project, check out the [Simple project](../examples/simple-project.md) example. + +## The development workflow + +Most of the time, the development workflow when using Garden after the configuration files are set is extremely simple: you leave `garden dev` running, and Garden will automatically re-build, re-deploy, and re-test your project as you work on it. + +Sometimes though you might prefer to skip the testing step, in which case you can simply use `garden deploy --watch`. This will watch for changes, then build and deploy them, but it'll skip testing. + +Another important topic to keep in mind is [inter-service communication](../basics/concepts.md#how-inter-service-communication-works). As previously discussed, your project has multiple services, and they need to talk to each other at some point. That's pretty simple: a service's hostname is simply its name. So a the hostname for a service called `my-service` is simply `http://my-service/`. + +For example, the following snippet calls a separate service in the project called `go-service`. + +```js +request.get('http://go-service/hello-go').then(message => {res.json({message})}) +``` + +Lastly, when things go wrong you should refer to the error logs. That's an `error.log` file in the project root, and the service logs that you can retrieve from the individual pods in your cluster. + +For the latter, you can use the `garden logs` command, followed by the name of the service you'd like to query. For example `garden logs go-service` would fetch the logs for the `go-service` service, while `garden logs go-service,node-service` would fetch the logs for both the `go-service` and the `node-service` services. + +The `garden logs` command is functionally equivalent to `kubectl logs`, but simpler to execute. + +## Providers + +Whenever "a module's type" is mentioned in the documentation, what's meant is "which provider will handle this module?" Providers, as [previously discussed](../basics/concepts.md), are responsible for implementing different behaviors for say containers and serverless functions, and they need to be specified in a module's configuration files. + +For a comprehensive list of providers available in Garden, check out the [References](../reference/README.md) + + +## Testing and dependencies + +Both tests and dependencies are specified in the Garden configuration files. + +Dependencies are a field within the services declaration. Here's a snippet, from our [TLS project](../examples/tls-project.md) example: + +```yaml +module: + name: node-service + description: Node service container + type: container + services: + - name: node-service + ... + dependencies: + - go-service +``` + +Tests should be specified the same way, and in the case of integration tests their dependencies should be present as well. Another snippet from the same file: + +```yaml +tests: + - name: unit + command: [npm, test] + - name: integ + command: [npm, run, integ] + dependencies: + - go-service +``` + +Above we're using `npm test` and `npm run integ` for our tests, but they can be anything you'd like. The only constraint is that Garden follows the typical Unix exit codes convention: `0` means success, and any non-zero exit codes represent failures. + +## Advanced features + +For Garden's more advanced features, see the following docs: + +- [Hot Reload](./hot-reload.md), for how to update the files in a container without having to restart it and lose state. +- [TLS project](../examples/tls-project.md), for—drumroll!—how to set up TLS with Garden. +- [Remote sources project](../examples/remote-sources.md), for how to integrate multiple remote and local repositories within the same project. diff --git a/docs/using-garden/hot-reload.md b/docs/using-garden/hot-reload.md new file mode 100644 index 00000000000..4716a2a3330 --- /dev/null +++ b/docs/using-garden/hot-reload.md @@ -0,0 +1,49 @@ +# Hot Reload + +When the `local-kubernetes` provider is used, `container` modules can be configured to hot-reload their running services when the module's sources change (i.e. without redeploying). In essence, hot-reloading copies source files into the appropriate running containers when code is changed by the user. + +For example, services that can be run with a file system watcher that automatically update the running application process when sources change (e.g. nodemon, Django, Ruby on Rails, and many other web app frameworks) are a natural fit for this feature. + +# Usage + +Currently, modules configured for hot reloading are only deployed with hot reloading enabled when they're deployed via `garden deploy -w` or `garden dev`; and not, for example, when deployed via `garden deploy` without the `-w` flag. + +Subsequently deploying a service belonging to a module configured for hot reloading via `garden deploy` (without the watch flag) results in the service being redeployed in standard configuration. (See [this link](https://github.com/garden-io/garden/pull/291) for a more technical discussion.) + +Since hot reloading is triggered via Garden's file system watcher, hot reloading only occurs while a `garden deploy -w`, `garden build -w`, or `garden dev` command is running. + +# Quick example + +Following is a simple example of a module configured for hot reloading: + +```yaml +module: + description: My Test Service + name: test-service + type: container + hotReload: + sync: + - target: /app/ + services: + - name: test-service + command: [npm, start] # runs `node main.js` + hotReloadCommand: [npm, run, dev] # runs `nodemon main.js` +``` + +In the above, the `hotReload` field specifies the destination path inside the running container that the module's (top-level) directory (where its `garden.yml` resides) is synced to. + +Note that only files tracked in version control are synced, e.g. respecting `.gitignore`. + +If a `source` is specified along with `target`, that subpath in the module's directory is synced to the target instead of the default of syncing the module's top-level directory. + +You can configure several such `source`/`target` pairs, but note that the `source` path must be disjoint, i.e. a `source` path may not be a subdirectory of another `source` path within the same module. Here's an example: + +```yaml + sync: + - source: /foo + target: /app/foo + - source: /bar + target: /app/bar +``` + +Lastly, `hotReloadCommand` determines which command should be ran inside the container (when deployed with hot reloading enabled). If no `hotReloadCommand` is specified, `command` is also used in hot reload mode. diff --git a/docs/using-garden/remote-clusters.md b/docs/using-garden/remote-clusters.md new file mode 100644 index 00000000000..9f5740a1d7a --- /dev/null +++ b/docs/using-garden/remote-clusters.md @@ -0,0 +1,130 @@ +# Using Garden with a remote Kubernetes cluster + +Below are some notes on steps you need to take before deploying Garden projects to a remote Kubernetes cluster. + +Many of the steps are not specific to Garden as such, so you may have already performed some of these steps +and/or may need to follow the provided links in each section for details on how to perform the steps you have +not yet completed. + +## Setup + +### Connecting to the cluster + +Start by making sure you have a [kubectl context](https://kubernetes.io/docs/tasks/access-application-cluster/configure-access-multiple-clusters/) +set up on your development machine to access your cluster. How you set this up will vary by how and where you +have deployed your cluster. + +Then configure the project and provider in your project `garden.yml`, along with the kubectl context you use to +connect to your cluster. + +Example: + +```yaml +project: + name: my-project + environments: + - name: dev + providers: + - name: kubernetes + context: my-dev-context # the name of the kubectl context for the cluster + ... + defaultEnvironment: dev +``` + +### Ingress, TLS and DNS + +The cluster needs to have a configured [nginx ingress controller](https://github.com/kubernetes/ingress-nginx). + +You'll also need to point one or more DNS entries to your cluster, and configure a TLS certificate for the hostnames +you will expose for ingress. +_How you configure DNS and prepare the certificates will depend on how you manage DNS and certificates in general, +so we won't cover that in detail here._ + +Once you have the certificates on hand (the `.crt` and `.key` files), create a +[Secret](https://kubernetes.io/docs/concepts/configuration/secret/) for each cert in the cluster so that +they can be referenced when deploying services: + +```sh +kubectl create secret tls mydomain-tls-secret --key --cert +``` + +Then configure each certificate/secret in your `garden.yml` provider configuration: + +```yaml +project: + name: my-project + environments: + - name: dev + providers: + - name: kubernetes + context: my-dev-context + tlsCertificates: + - name: main + # Optionally set particular hostnames to use this certificate for + # (useful if you have multiple certs for the same hostname). + hostnames: [mydomain.com] + secretRef: + # Change to whatever name you chose for the secret above. + name: my-tls-secret + # Change this if you store the secret in another namespace. + namespace: default + - name: wildcard + secretRef: + name: wildcard-tls-secret + namespace: default + ... + defaultEnvironment: dev +``` + +### Configuring a container registry + +When you deploy to the environment (via `garden deploy` or `garden dev`), containers are first built and then pushed +to the configured _deployment registry_, where the K8s cluster will then pull the built images when deploying. +This should generally be a _private_ container registry, or at least a private project in a public registry. + +Similarly to the above TLS configuration, you may also need to set up auth for the registry using K8s Secrets, in this +case via the `kubectl create secret docker-registry` helper. + +_Note that you do not need to configure the authentication and imagePullSecrets when using GKE along with GCR, +as long as your deployment registry is in the same project as the GKE cluster._ + +The lovely folks at [Heptio](https://heptio.com) have prepared good guides on how to configure private registries +for Kubernetes, which you can find [here](http://docs.heptio.com/content/private-registries.html). + +Once you've created the auth secret in the cluster, you can configure the registry and the secrets in your +`garden.yml` project config like this: + +```yaml +project: + name: my-project + environments: + - name: dev + providers: + - name: kubernetes + context: my-dev-context + ... + deploymentRegistry: + # The hostname of the registry, e.g. gcr.io for GCR (Google Container Registry) + hostname: my.registry.io + # Namespace (aka project ID) to use in the registry for this project. + # For GKE/GCR, use the project ID where your cluster is. + namespace: my-project-id + imagePullSecrets: + # The name of the secret you stored using `kubectl create secret docker-registry` + - name: my-registry-secret + # Change this if you store the secret in another namespace. + namespace: default + defaultEnvironment: dev +``` + +You also need to login to the `docker` CLI, so that images can be pushed to the registry. Please refer +to your registry's documentation on how to do that (for Docker Hub you simply run `docker login`). + +### Permissions + +Note that you need to have permissions to create namespaces and to create deployments, +daemonsets, services and ingresses within the namespaces created. + +The plugin will create two or more namespaces per user and project, one to run services, another to manage +metadata and configuration (this is so that your environment can be reset without +clearing your configuration variables), and potentially more to support specific plugins/providers. \ No newline at end of file diff --git a/garden-cli/garden-cli b/garden-cli/garden-cli new file mode 100755 index 00000000000..f90024a76a5 Binary files /dev/null and b/garden-cli/garden-cli differ diff --git a/garden-service/build/actions.d.ts b/garden-service/build/actions.d.ts new file mode 100644 index 00000000000..e2091961f8a --- /dev/null +++ b/garden-service/build/actions.d.ts @@ -0,0 +1,81 @@ +import { Garden } from "./garden"; +import { PrimitiveMap } from "./config/common"; +import { Module } from "./types/module"; +import { BuildResult, BuildStatus, DeleteSecretResult, EnvironmentStatusMap, ExecInServiceResult, GetSecretResult, GetServiceLogsResult, PushResult, RunResult, SetSecretResult, TestResult, PublishResult } from "./types/plugin/outputs"; +import { BuildModuleParams, DeleteSecretParams, DeployServiceParams, DeleteServiceParams, ExecInServiceParams, GetSecretParams, GetBuildStatusParams, GetServiceLogsParams, GetServiceOutputsParams, GetServiceStatusParams, GetTestResultParams, ModuleActionParams, PluginActionContextParams, PluginActionParams, PluginActionParamsBase, PluginServiceActionParamsBase, PushModuleParams, RunModuleParams, RunServiceParams, SetSecretParams, TestModuleParams, GetEnvironmentStatusParams, PluginModuleActionParamsBase, PublishModuleParams } from "./types/plugin/params"; +import { ServiceStatus } from "./types/service"; +import { Omit } from "./util/util"; +import { RuntimeContext } from "./types/service"; +import { ProcessResults } from "./process"; +import { LogEntry } from "./logger/log-entry"; +import { CleanupEnvironmentParams } from "./types/plugin/params"; +declare type TypeGuard = { + readonly [P in keyof (PluginActionParams | ModuleActionParams)]: (...args: any[]) => Promise; +}; +export interface ContextStatus { + providers: EnvironmentStatusMap; + services: { + [name: string]: ServiceStatus; + }; +} +export interface DeployServicesParams { + serviceNames?: string[]; + force?: boolean; + forceBuild?: boolean; +} +declare type ActionHelperParams = Omit & { + pluginName?: string; +}; +declare type ModuleActionHelperParams = Omit & { + pluginName?: string; +}; +declare type ServiceActionHelperParams = Omit & { + runtimeContext?: RuntimeContext; + pluginName?: string; +}; +declare type RequirePluginName = T & { + pluginName: string; +}; +export declare class ActionHelper implements TypeGuard { + private garden; + constructor(garden: Garden); + getEnvironmentStatus({ pluginName }: ActionHelperParams): Promise; + /** + * Checks environment status and calls prepareEnvironment for each provider that isn't flagged as ready. + * + * If any of the getEnvironmentStatus handlers returns needUserInput=true, this throws and guides the user to + * run `garden init` + */ + prepareEnvironment({ force, pluginName, logEntry, allowUserInput }: { + force?: boolean; + pluginName?: string; + logEntry?: LogEntry; + allowUserInput?: boolean; + }): Promise<{}>; + cleanupEnvironment({ pluginName }: ActionHelperParams): Promise; + getSecret(params: RequirePluginName>): Promise; + setSecret(params: RequirePluginName>): Promise; + deleteSecret(params: RequirePluginName>): Promise; + getBuildStatus(params: ModuleActionHelperParams>): Promise; + build(params: ModuleActionHelperParams>): Promise; + pushModule(params: ModuleActionHelperParams>): Promise; + publishModule(params: ModuleActionHelperParams>): Promise; + runModule(params: ModuleActionHelperParams>): Promise; + testModule(params: ModuleActionHelperParams>): Promise; + getTestResult(params: ModuleActionHelperParams>): Promise; + getServiceStatus(params: ServiceActionHelperParams): Promise; + deployService(params: ServiceActionHelperParams): Promise; + deleteService(params: ServiceActionHelperParams): Promise; + getServiceOutputs(params: ServiceActionHelperParams): Promise; + execInService(params: ServiceActionHelperParams): Promise; + getServiceLogs(params: ServiceActionHelperParams): Promise; + runService(params: ServiceActionHelperParams): Promise; + getStatus(): Promise; + deployServices({ serviceNames, force, forceBuild }: DeployServicesParams): Promise; + private commonParams; + private callActionHandler; + private callModuleHandler; + private callServiceHandler; +} +export {}; +//# sourceMappingURL=actions.d.ts.map \ No newline at end of file diff --git a/garden-service/build/actions.js b/garden-service/build/actions.js new file mode 100644 index 00000000000..fee9eae75b1 --- /dev/null +++ b/garden-service/build/actions.js @@ -0,0 +1,319 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const chalk_1 = require("chalk"); +const service_1 = require("./types/service"); +const lodash_1 = require("lodash"); +const process_1 = require("./process"); +const deploy_1 = require("./tasks/deploy"); +const plugin_context_1 = require("./plugin-context"); +const exceptions_1 = require("./exceptions"); +class ActionHelper { + constructor(garden) { + this.garden = garden; + } + //=========================================================================== + //region Environment Actions + //=========================================================================== + getEnvironmentStatus({ pluginName }) { + return __awaiter(this, void 0, void 0, function* () { + const handlers = this.garden.getActionHandlers("getEnvironmentStatus", pluginName); + return Bluebird.props(lodash_1.mapValues(handlers, h => h(Object.assign({}, this.commonParams(h))))); + }); + } + /** + * Checks environment status and calls prepareEnvironment for each provider that isn't flagged as ready. + * + * If any of the getEnvironmentStatus handlers returns needUserInput=true, this throws and guides the user to + * run `garden init` + */ + prepareEnvironment({ force = false, pluginName, logEntry, allowUserInput = false }) { + return __awaiter(this, void 0, void 0, function* () { + const handlers = this.garden.getActionHandlers("prepareEnvironment", pluginName); + const statuses = yield this.getEnvironmentStatus({ pluginName }); + const needUserInput = Object.entries(statuses) + .map(([name, status]) => (Object.assign({}, status, { name }))) + .filter(status => status.needUserInput === true); + if (!allowUserInput && needUserInput.length > 0) { + const names = needUserInput.map(s => s.name).join(", "); + const msgPrefix = needUserInput.length === 1 + ? `Plugin ${names} has been updated or hasn't been configured, and requires user input.` + : `Plugins ${names} have been updated or haven't been configured, and require user input.`; + throw new exceptions_1.ConfigurationError(`${msgPrefix}. Please run \`garden init\` and then re-run this command.`, { statuses }); + } + const output = {}; + // sequentially go through the preparation steps, to allow plugins to request user input + for (const [name, handler] of Object.entries(handlers)) { + const status = statuses[name] || { ready: false }; + if (status.ready && !force) { + continue; + } + const envLogEntry = (logEntry || this.garden.log).info({ + status: "active", + section: name, + msg: "Preparing environment...", + }); + yield handler(Object.assign({}, this.commonParams(handler), { force, status, logEntry: envLogEntry })); + envLogEntry.setSuccess("Configured"); + output[name] = true; + } + return output; + }); + } + cleanupEnvironment({ pluginName }) { + return __awaiter(this, void 0, void 0, function* () { + const handlers = this.garden.getActionHandlers("cleanupEnvironment", pluginName); + yield Bluebird.each(lodash_1.values(handlers), h => h(Object.assign({}, this.commonParams(h)))); + return this.getEnvironmentStatus({ pluginName }); + }); + } + getSecret(params) { + return __awaiter(this, void 0, void 0, function* () { + const { pluginName } = params; + return this.callActionHandler({ actionType: "getSecret", pluginName, params: lodash_1.omit(params, ["pluginName"]) }); + }); + } + setSecret(params) { + return __awaiter(this, void 0, void 0, function* () { + const { pluginName } = params; + return this.callActionHandler({ actionType: "setSecret", pluginName, params: lodash_1.omit(params, ["pluginName"]) }); + }); + } + deleteSecret(params) { + return __awaiter(this, void 0, void 0, function* () { + const { pluginName } = params; + return this.callActionHandler({ actionType: "deleteSecret", pluginName, params: lodash_1.omit(params, ["pluginName"]) }); + }); + } + //endregion + //=========================================================================== + //region Module Actions + //=========================================================================== + getBuildStatus(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callModuleHandler({ + params, + actionType: "getBuildStatus", + defaultHandler: () => __awaiter(this, void 0, void 0, function* () { return ({ ready: false }); }), + }); + }); + } + build(params) { + return __awaiter(this, void 0, void 0, function* () { + yield this.garden.buildDir.syncDependencyProducts(params.module); + return this.callModuleHandler({ params, actionType: "build" }); + }); + } + pushModule(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callModuleHandler({ params, actionType: "pushModule", defaultHandler: dummyPushHandler }); + }); + } + publishModule(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callModuleHandler({ params, actionType: "publishModule", defaultHandler: dummyPublishHandler }); + }); + } + runModule(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callModuleHandler({ params, actionType: "runModule" }); + }); + } + testModule(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callModuleHandler({ params, actionType: "testModule" }); + }); + } + getTestResult(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callModuleHandler({ + params, + actionType: "getTestResult", + defaultHandler: () => __awaiter(this, void 0, void 0, function* () { return null; }), + }); + }); + } + //endregion + //=========================================================================== + //region Service Actions + //=========================================================================== + getServiceStatus(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callServiceHandler({ params, actionType: "getServiceStatus" }); + }); + } + deployService(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callServiceHandler({ params, actionType: "deployService" }); + }); + } + deleteService(params) { + return __awaiter(this, void 0, void 0, function* () { + const logEntry = this.garden.log.info({ + section: params.service.name, + msg: "Deleting...", + status: "active", + }); + return this.callServiceHandler({ + params: Object.assign({}, params, { logEntry }), + actionType: "deleteService", + defaultHandler: dummyDeleteServiceHandler, + }); + }); + } + getServiceOutputs(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callServiceHandler({ + params, + actionType: "getServiceOutputs", + defaultHandler: () => __awaiter(this, void 0, void 0, function* () { return ({}); }), + }); + }); + } + execInService(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callServiceHandler({ params, actionType: "execInService" }); + }); + } + getServiceLogs(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callServiceHandler({ params, actionType: "getServiceLogs", defaultHandler: dummyLogStreamer }); + }); + } + runService(params) { + return __awaiter(this, void 0, void 0, function* () { + return this.callServiceHandler({ params, actionType: "runService" }); + }); + } + //endregion + //=========================================================================== + //region Helper Methods + //=========================================================================== + getStatus() { + return __awaiter(this, void 0, void 0, function* () { + const envStatus = yield this.getEnvironmentStatus({}); + const services = lodash_1.keyBy(yield this.garden.getServices(), "name"); + const serviceStatus = yield Bluebird.props(lodash_1.mapValues(services, (service) => __awaiter(this, void 0, void 0, function* () { + const dependencies = yield this.garden.getServices(service.config.dependencies); + const runtimeContext = yield service_1.prepareRuntimeContext(this.garden, service.module, dependencies); + return this.getServiceStatus({ service, runtimeContext }); + }))); + return { + providers: envStatus, + services: serviceStatus, + }; + }); + } + deployServices({ serviceNames, force = false, forceBuild = false }) { + return __awaiter(this, void 0, void 0, function* () { + const services = yield this.garden.getServices(serviceNames); + return process_1.processServices({ + services, + garden: this.garden, + watch: false, + handler: (module) => __awaiter(this, void 0, void 0, function* () { + return deploy_1.getDeployTasks({ + garden: this.garden, + module, + serviceNames, + force, + forceBuild, + includeDependants: false, + }); + }), + }); + }); + } + //endregion + // TODO: find a nicer way to do this (like a type-safe wrapper function) + commonParams(handler, logEntry) { + return { + ctx: plugin_context_1.createPluginContext(this.garden, handler["pluginName"]), + // TODO: find a better way for handlers to log during execution + logEntry, + }; + } + callActionHandler({ params, actionType, pluginName, defaultHandler }) { + return __awaiter(this, void 0, void 0, function* () { + const handler = this.garden.getActionHandler({ + actionType, + pluginName, + defaultHandler, + }); + const handlerParams = Object.assign({}, this.commonParams(handler), params); + return handler(handlerParams); + }); + } + callModuleHandler({ params, actionType, defaultHandler }) { + return __awaiter(this, void 0, void 0, function* () { + // the type system is messing me up here, not sure why I need the any cast... - j.e. + const { module, pluginName } = params; + const handler = yield this.garden.getModuleActionHandler({ + moduleType: module.type, + actionType, + pluginName, + defaultHandler, + }); + const handlerParams = Object.assign({}, this.commonParams(handler), lodash_1.omit(params, ["module"]), { module: lodash_1.omit(module, ["_ConfigType"]) }); + // TODO: figure out why this doesn't compile without the function cast + return handler(handlerParams); + }); + } + callServiceHandler({ params, actionType, defaultHandler }) { + return __awaiter(this, void 0, void 0, function* () { + const { service } = params; + const module = service.module; + const handler = yield this.garden.getModuleActionHandler({ + moduleType: module.type, + actionType, + pluginName: params.pluginName, + defaultHandler, + }); + // TODO: figure out why this doesn't compile without the casts + const deps = yield this.garden.getServices(service.config.dependencies); + const runtimeContext = (params.runtimeContext || (yield service_1.prepareRuntimeContext(this.garden, module, deps))); + const handlerParams = Object.assign({}, this.commonParams(handler), params, { module, + runtimeContext }); + return handler(handlerParams); + }); + } +} +exports.ActionHelper = ActionHelper; +const dummyLogStreamer = ({ service, logEntry }) => __awaiter(this, void 0, void 0, function* () { + logEntry && logEntry.warn({ + section: service.name, + msg: chalk_1.default.yellow(`No handler for log retrieval available for module type ${service.module.type}`), + }); + return {}; +}); +const dummyPushHandler = () => __awaiter(this, void 0, void 0, function* () { + return { pushed: false }; +}); +const dummyPublishHandler = ({ module }) => __awaiter(this, void 0, void 0, function* () { + return { + message: chalk_1.default.yellow(`No publish handler available for module type ${module.type}`), + published: false, + }; +}); +const dummyDeleteServiceHandler = ({ module, logEntry }) => __awaiter(this, void 0, void 0, function* () { + const msg = `No delete service handler available for module type ${module.type}`; + logEntry && logEntry.setError(msg); + return {}; +}); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["actions.ts"],"names":[],"mappings":"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","file":"actions.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport Bluebird = require(\"bluebird\")\nimport chalk from \"chalk\"\nimport { Garden } from \"./garden\"\nimport { PrimitiveMap } from \"./config/common\"\nimport { Module } from \"./types/module\"\nimport { ModuleActions, ServiceActions, PluginActions } from \"./types/plugin/plugin\"\nimport {\n  BuildResult,\n  BuildStatus,\n  DeleteSecretResult,\n  EnvironmentStatusMap,\n  ExecInServiceResult,\n  GetSecretResult,\n  GetServiceLogsResult,\n  ModuleActionOutputs,\n  PushResult,\n  RunResult,\n  ServiceActionOutputs,\n  SetSecretResult,\n  TestResult,\n  PluginActionOutputs,\n  PublishResult,\n} from \"./types/plugin/outputs\"\nimport {\n  BuildModuleParams,\n  DeleteSecretParams,\n  DeployServiceParams,\n  DeleteServiceParams,\n  ExecInServiceParams,\n  GetSecretParams,\n  GetBuildStatusParams,\n  GetServiceLogsParams,\n  GetServiceOutputsParams,\n  GetServiceStatusParams,\n  GetTestResultParams,\n  ModuleActionParams,\n  PluginActionContextParams,\n  PluginActionParams,\n  PluginActionParamsBase,\n  PluginServiceActionParamsBase,\n  PushModuleParams,\n  RunModuleParams,\n  RunServiceParams,\n  ServiceActionParams,\n  SetSecretParams,\n  TestModuleParams,\n  GetEnvironmentStatusParams,\n  PluginModuleActionParamsBase,\n  PublishModuleParams,\n} from \"./types/plugin/params\"\nimport {\n  Service,\n  ServiceStatus,\n  prepareRuntimeContext,\n} from \"./types/service\"\nimport { mapValues, values, keyBy, omit } from \"lodash\"\nimport { Omit } from \"./util/util\"\nimport { RuntimeContext } from \"./types/service\"\nimport { processServices, ProcessResults } from \"./process\"\nimport { getDeployTasks } from \"./tasks/deploy\"\nimport { LogEntry } from \"./logger/log-entry\"\nimport { createPluginContext } from \"./plugin-context\"\nimport { CleanupEnvironmentParams } from \"./types/plugin/params\"\nimport { ConfigurationError } from \"./exceptions\"\n\ntype TypeGuard = {\n  readonly [P in keyof (PluginActionParams | ModuleActionParams<any>)]: (...args: any[]) => Promise<any>\n}\n\nexport interface ContextStatus {\n  providers: EnvironmentStatusMap\n  services: { [name: string]: ServiceStatus }\n}\n\nexport interface DeployServicesParams {\n  serviceNames?: string[],\n  force?: boolean\n  forceBuild?: boolean\n}\n\n// avoid having to specify common params on each action helper call\ntype ActionHelperParams<T extends PluginActionParamsBase> =\n  Omit<T, keyof PluginActionContextParams> & { pluginName?: string }\ntype ModuleActionHelperParams<T extends PluginModuleActionParamsBase> =\n  Omit<T, keyof PluginActionContextParams> & { pluginName?: string }\n// additionally make runtimeContext param optional\ntype ServiceActionHelperParams<T extends PluginServiceActionParamsBase> =\n  Omit<T, \"module\" | \"runtimeContext\" | keyof PluginActionContextParams>\n  & { runtimeContext?: RuntimeContext, pluginName?: string }\n\ntype RequirePluginName<T> = T & { pluginName: string }\n\nexport class ActionHelper implements TypeGuard {\n  constructor(private garden: Garden) { }\n\n  //===========================================================================\n  //region Environment Actions\n  //===========================================================================\n\n  async getEnvironmentStatus(\n    { pluginName }: ActionHelperParams<GetEnvironmentStatusParams>,\n  ): Promise<EnvironmentStatusMap> {\n    const handlers = this.garden.getActionHandlers(\"getEnvironmentStatus\", pluginName)\n    return Bluebird.props(mapValues(handlers, h => h({ ...this.commonParams(h) })))\n  }\n\n  /**\n   * Checks environment status and calls prepareEnvironment for each provider that isn't flagged as ready.\n   *\n   * If any of the getEnvironmentStatus handlers returns needUserInput=true, this throws and guides the user to\n   * run `garden init`\n   */\n  async prepareEnvironment(\n    { force = false, pluginName, logEntry, allowUserInput = false }:\n      { force?: boolean, pluginName?: string, logEntry?: LogEntry, allowUserInput?: boolean },\n  ) {\n    const handlers = this.garden.getActionHandlers(\"prepareEnvironment\", pluginName)\n    const statuses = await this.getEnvironmentStatus({ pluginName })\n\n    const needUserInput = Object.entries(statuses)\n      .map(([name, status]) => ({ ...status, name }))\n      .filter(status => status.needUserInput === true)\n\n    if (!allowUserInput && needUserInput.length > 0) {\n      const names = needUserInput.map(s => s.name).join(\", \")\n      const msgPrefix = needUserInput.length === 1\n        ? `Plugin ${names} has been updated or hasn't been configured, and requires user input.`\n        : `Plugins ${names} have been updated or haven't been configured, and require user input.`\n\n      throw new ConfigurationError(\n        `${msgPrefix}. Please run \\`garden init\\` and then re-run this command.`,\n        { statuses },\n      )\n    }\n\n    const output = {}\n\n    // sequentially go through the preparation steps, to allow plugins to request user input\n    for (const [name, handler] of Object.entries(handlers)) {\n      const status = statuses[name] || { ready: false }\n\n      if (status.ready && !force) {\n        continue\n      }\n\n      const envLogEntry = (logEntry || this.garden.log).info({\n        status: \"active\",\n        section: name,\n        msg: \"Preparing environment...\",\n      })\n\n      await handler({ ...this.commonParams(handler), force, status, logEntry: envLogEntry })\n\n      envLogEntry.setSuccess(\"Configured\")\n\n      output[name] = true\n    }\n\n    return output\n  }\n\n  async cleanupEnvironment(\n    { pluginName }: ActionHelperParams<CleanupEnvironmentParams>,\n  ): Promise<EnvironmentStatusMap> {\n    const handlers = this.garden.getActionHandlers(\"cleanupEnvironment\", pluginName)\n    await Bluebird.each(values(handlers), h => h({ ...this.commonParams(h) }))\n    return this.getEnvironmentStatus({ pluginName })\n  }\n\n  async getSecret(params: RequirePluginName<ActionHelperParams<GetSecretParams>>): Promise<GetSecretResult> {\n    const { pluginName } = params\n    return this.callActionHandler({ actionType: \"getSecret\", pluginName, params: omit(params, [\"pluginName\"]) })\n  }\n\n  async setSecret(params: RequirePluginName<ActionHelperParams<SetSecretParams>>): Promise<SetSecretResult> {\n    const { pluginName } = params\n    return this.callActionHandler({ actionType: \"setSecret\", pluginName, params: omit(params, [\"pluginName\"]) })\n  }\n\n  async deleteSecret(params: RequirePluginName<ActionHelperParams<DeleteSecretParams>>): Promise<DeleteSecretResult> {\n    const { pluginName } = params\n    return this.callActionHandler({ actionType: \"deleteSecret\", pluginName, params: omit(params, [\"pluginName\"]) })\n  }\n\n  //endregion\n\n  //===========================================================================\n  //region Module Actions\n  //===========================================================================\n\n  async getBuildStatus<T extends Module>(\n    params: ModuleActionHelperParams<GetBuildStatusParams<T>>,\n  ): Promise<BuildStatus> {\n    return this.callModuleHandler({\n      params,\n      actionType: \"getBuildStatus\",\n      defaultHandler: async () => ({ ready: false }),\n    })\n  }\n\n  async build<T extends Module>(params: ModuleActionHelperParams<BuildModuleParams<T>>): Promise<BuildResult> {\n    await this.garden.buildDir.syncDependencyProducts(params.module)\n    return this.callModuleHandler({ params, actionType: \"build\" })\n  }\n\n  async pushModule<T extends Module>(params: ModuleActionHelperParams<PushModuleParams<T>>): Promise<PushResult> {\n    return this.callModuleHandler({ params, actionType: \"pushModule\", defaultHandler: dummyPushHandler })\n  }\n\n  async publishModule<T extends Module>(\n    params: ModuleActionHelperParams<PublishModuleParams<T>>,\n  ): Promise<PublishResult> {\n    return this.callModuleHandler({ params, actionType: \"publishModule\", defaultHandler: dummyPublishHandler })\n  }\n\n  async runModule<T extends Module>(params: ModuleActionHelperParams<RunModuleParams<T>>): Promise<RunResult> {\n    return this.callModuleHandler({ params, actionType: \"runModule\" })\n  }\n\n  async testModule<T extends Module>(params: ModuleActionHelperParams<TestModuleParams<T>>): Promise<TestResult> {\n    return this.callModuleHandler({ params, actionType: \"testModule\" })\n  }\n\n  async getTestResult<T extends Module>(\n    params: ModuleActionHelperParams<GetTestResultParams<T>>,\n  ): Promise<TestResult | null> {\n    return this.callModuleHandler({\n      params,\n      actionType: \"getTestResult\",\n      defaultHandler: async () => null,\n    })\n  }\n\n  //endregion\n\n  //===========================================================================\n  //region Service Actions\n  //===========================================================================\n\n  async getServiceStatus(params: ServiceActionHelperParams<GetServiceStatusParams>): Promise<ServiceStatus> {\n    return this.callServiceHandler({ params, actionType: \"getServiceStatus\" })\n  }\n\n  async deployService(params: ServiceActionHelperParams<DeployServiceParams>): Promise<ServiceStatus> {\n    return this.callServiceHandler({ params, actionType: \"deployService\" })\n  }\n\n  async deleteService(params: ServiceActionHelperParams<DeleteServiceParams>): Promise<ServiceStatus> {\n    const logEntry = this.garden.log.info({\n      section: params.service.name,\n      msg: \"Deleting...\",\n      status: \"active\",\n    })\n    return this.callServiceHandler({\n      params: { ...params, logEntry },\n      actionType: \"deleteService\",\n      defaultHandler: dummyDeleteServiceHandler,\n    })\n  }\n\n  async getServiceOutputs(params: ServiceActionHelperParams<GetServiceOutputsParams>): Promise<PrimitiveMap> {\n    return this.callServiceHandler({\n      params,\n      actionType: \"getServiceOutputs\",\n      defaultHandler: async () => ({}),\n    })\n  }\n\n  async execInService(params: ServiceActionHelperParams<ExecInServiceParams>): Promise<ExecInServiceResult> {\n    return this.callServiceHandler({ params, actionType: \"execInService\" })\n  }\n\n  async getServiceLogs(params: ServiceActionHelperParams<GetServiceLogsParams>): Promise<GetServiceLogsResult> {\n    return this.callServiceHandler({ params, actionType: \"getServiceLogs\", defaultHandler: dummyLogStreamer })\n  }\n\n  async runService(params: ServiceActionHelperParams<RunServiceParams>): Promise<RunResult> {\n    return this.callServiceHandler({ params, actionType: \"runService\" })\n  }\n\n  //endregion\n\n  //===========================================================================\n  //region Helper Methods\n  //===========================================================================\n\n  async getStatus(): Promise<ContextStatus> {\n    const envStatus: EnvironmentStatusMap = await this.getEnvironmentStatus({})\n    const services = keyBy(await this.garden.getServices(), \"name\")\n\n    const serviceStatus = await Bluebird.props(mapValues(services, async (service: Service) => {\n      const dependencies = await this.garden.getServices(service.config.dependencies)\n      const runtimeContext = await prepareRuntimeContext(this.garden, service.module, dependencies)\n      return this.getServiceStatus({ service, runtimeContext })\n    }))\n\n    return {\n      providers: envStatus,\n      services: serviceStatus,\n    }\n  }\n\n  async deployServices(\n    { serviceNames, force = false, forceBuild = false }: DeployServicesParams,\n  ): Promise<ProcessResults> {\n    const services = await this.garden.getServices(serviceNames)\n\n    return processServices({\n      services,\n      garden: this.garden,\n      watch: false,\n      handler: async (module) => getDeployTasks({\n        garden: this.garden,\n        module,\n        serviceNames,\n        force,\n        forceBuild,\n        includeDependants: false,\n      }),\n    })\n  }\n\n  //endregion\n\n  // TODO: find a nicer way to do this (like a type-safe wrapper function)\n  private commonParams(handler, logEntry?: LogEntry): PluginActionParamsBase {\n    return {\n      ctx: createPluginContext(this.garden, handler[\"pluginName\"]),\n      // TODO: find a better way for handlers to log during execution\n      logEntry,\n    }\n  }\n\n  private async callActionHandler<T extends keyof PluginActions>(\n    { params, actionType, pluginName, defaultHandler }:\n      {\n        params: ActionHelperParams<PluginActionParams[T]>,\n        actionType: T,\n        pluginName?: string,\n        defaultHandler?: PluginActions[T],\n      },\n  ): Promise<PluginActionOutputs[T]> {\n    const handler = this.garden.getActionHandler({\n      actionType,\n      pluginName,\n      defaultHandler,\n    })\n    const handlerParams: PluginActionParams[T] = {\n      ...this.commonParams(handler),\n      ...<object>params,\n    }\n    return (<Function>handler)(handlerParams)\n  }\n\n  private async callModuleHandler<T extends keyof Omit<ModuleActions, \"describeType\" | \"validate\">>(\n    { params, actionType, defaultHandler }:\n      { params: ModuleActionHelperParams<ModuleActionParams[T]>, actionType: T, defaultHandler?: ModuleActions[T] },\n  ): Promise<ModuleActionOutputs[T]> {\n    // the type system is messing me up here, not sure why I need the any cast... - j.e.\n    const { module, pluginName } = <any>params\n    const handler = await this.garden.getModuleActionHandler({\n      moduleType: module.type,\n      actionType,\n      pluginName,\n      defaultHandler,\n    })\n    const handlerParams: any = {\n      ...this.commonParams(handler),\n      ...omit(<object>params, [\"module\"]),\n      module: omit(module, [\"_ConfigType\"]),\n    }\n    // TODO: figure out why this doesn't compile without the function cast\n    return (<Function>handler)(handlerParams)\n  }\n\n  private async callServiceHandler<T extends keyof ServiceActions>(\n    { params, actionType, defaultHandler }:\n      { params: ServiceActionHelperParams<ServiceActionParams[T]>, actionType: T, defaultHandler?: ServiceActions[T] },\n  ): Promise<ServiceActionOutputs[T]> {\n    const { service } = <any>params\n    const module = service.module\n\n    const handler = await this.garden.getModuleActionHandler({\n      moduleType: module.type,\n      actionType,\n      pluginName: params.pluginName,\n      defaultHandler,\n    })\n\n    // TODO: figure out why this doesn't compile without the casts\n    const deps = await this.garden.getServices(service.config.dependencies)\n    const runtimeContext = ((<any>params).runtimeContext || await prepareRuntimeContext(this.garden, module, deps))\n\n    const handlerParams: any = {\n      ...this.commonParams(handler),\n      ...<object>params,\n      module,\n      runtimeContext,\n    }\n\n    return (<Function>handler)(handlerParams)\n  }\n}\n\nconst dummyLogStreamer = async ({ service, logEntry }: GetServiceLogsParams) => {\n  logEntry && logEntry.warn({\n    section: service.name,\n    msg: chalk.yellow(`No handler for log retrieval available for module type ${service.module.type}`),\n  })\n  return {}\n}\n\nconst dummyPushHandler = async () => {\n  return { pushed: false }\n}\n\nconst dummyPublishHandler = async ({ module }) => {\n  return {\n    message: chalk.yellow(`No publish handler available for module type ${module.type}`),\n    published: false,\n  }\n}\n\nconst dummyDeleteServiceHandler = async ({ module, logEntry }: DeleteServiceParams) => {\n  const msg = `No delete service handler available for module type ${module.type}`\n  logEntry && logEntry.setError(msg)\n  return {}\n}\n"]} diff --git a/garden-service/build/build-dir.d.ts b/garden-service/build/build-dir.d.ts new file mode 100644 index 00000000000..0630809de39 --- /dev/null +++ b/garden-service/build/build-dir.d.ts @@ -0,0 +1,13 @@ +import { Module } from "./types/module"; +export declare class BuildDir { + private projectRoot; + buildDirPath: string; + constructor(projectRoot: string, buildDirPath: string); + static factory(projectRoot: string): Promise; + syncFromSrc(module: Module): Promise; + syncDependencyProducts(module: Module): Promise; + clear(): Promise; + buildPath(moduleName: string): Promise; + private sync; +} +//# sourceMappingURL=build-dir.d.ts.map \ No newline at end of file diff --git a/garden-service/build/build-dir.js b/garden-service/build/build-dir.js new file mode 100644 index 00000000000..26899f1dadd --- /dev/null +++ b/garden-service/build/build-dir.js @@ -0,0 +1,110 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const bluebird_1 = require("bluebird"); +const path_1 = require("path"); +const fs_extra_1 = require("fs-extra"); +const constants_1 = require("./constants"); +const exceptions_1 = require("./exceptions"); +const module_1 = require("./types/module"); +const lodash_1 = require("lodash"); +const execa = require("execa"); +const os_1 = require("os"); +const util_1 = require("./util/util"); +// Lazily construct a directory of modules inside which all build steps are performed. +const buildDirRelPath = path_1.join(constants_1.GARDEN_DIR_NAME, "build"); +class BuildDir { + constructor(projectRoot, buildDirPath) { + this.projectRoot = projectRoot; + this.buildDirPath = buildDirPath; + } + static factory(projectRoot) { + return __awaiter(this, void 0, void 0, function* () { + const buildDirPath = path_1.join(projectRoot, buildDirRelPath); + yield fs_extra_1.ensureDir(buildDirPath); + return new BuildDir(projectRoot, buildDirPath); + }); + } + syncFromSrc(module) { + return __awaiter(this, void 0, void 0, function* () { + yield this.sync(path_1.resolve(this.projectRoot, module.path) + path_1.sep, yield this.buildPath(module.name)); + }); + } + syncDependencyProducts(module) { + return __awaiter(this, void 0, void 0, function* () { + yield this.syncFromSrc(module); + const buildPath = yield this.buildPath(module.name); + const buildDependencies = yield module.build.dependencies; + const dependencyConfigs = module.build.dependencies || []; + yield bluebird_1.map(lodash_1.zip(buildDependencies, dependencyConfigs), ([sourceModule, depConfig]) => __awaiter(this, void 0, void 0, function* () { + if (!sourceModule || !depConfig || !depConfig.copy) { + return; + } + const sourceBuildPath = yield this.buildPath(module_1.getModuleKey(sourceModule.name, sourceModule.plugin)); + // Sync to the module's top-level dir by default. + yield bluebird_1.map(depConfig.copy, (copy) => { + if (path_1.isAbsolute(copy.source)) { + throw new exceptions_1.ConfigurationError(`Source path in build dependency copy spec must be a relative path`, { + copySpec: copy, + }); + } + if (path_1.isAbsolute(copy.target)) { + throw new exceptions_1.ConfigurationError(`Target path in build dependency copy spec must be a relative path`, { + copySpec: copy, + }); + } + const sourcePath = path_1.join(sourceBuildPath, copy.source); + const destinationPath = path_1.join(buildPath, copy.target); + return this.sync(sourcePath, destinationPath); + }); + })); + }); + } + clear() { + return __awaiter(this, void 0, void 0, function* () { + yield fs_extra_1.emptyDir(this.buildDirPath); + }); + } + buildPath(moduleName) { + return __awaiter(this, void 0, void 0, function* () { + const path = path_1.resolve(this.buildDirPath, moduleName); + yield fs_extra_1.ensureDir(path); + return path; + }); + } + sync(sourcePath, destinationPath) { + return __awaiter(this, void 0, void 0, function* () { + const destinationDir = path_1.parse(destinationPath).dir; + yield fs_extra_1.ensureDir(destinationDir); + if (os_1.platform() === "win32") { + // this is so that the cygwin-based rsync client can deal with the paths + sourcePath = util_1.toCygwinPath(sourcePath); + destinationPath = util_1.toCygwinPath(destinationPath); + } + // the correct way to copy all contents of a folder is using a trailing slash and not a wildcard + sourcePath = stripWildcard(sourcePath); + destinationPath = stripWildcard(destinationPath); + yield execa("rsync", ["-rptgo", sourcePath, destinationPath]); + }); + } +} +exports.BuildDir = BuildDir; +function stripWildcard(path) { + return path.endsWith("/*") ? path.slice(0, -1) : path; +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["build-dir.ts"],"names":[],"mappings":"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","file":"build-dir.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { map as bluebirdMap } from \"bluebird\"\nimport {\n  isAbsolute,\n  join,\n  parse,\n  resolve,\n  sep,\n} from \"path\"\nimport {\n  emptyDir,\n  ensureDir,\n} from \"fs-extra\"\nimport { GARDEN_DIR_NAME } from \"./constants\"\nimport { ConfigurationError } from \"./exceptions\"\nimport {\n  BuildCopySpec,\n  Module,\n  getModuleKey,\n} from \"./types/module\"\nimport { zip } from \"lodash\"\nimport * as execa from \"execa\"\nimport { platform } from \"os\"\nimport { toCygwinPath } from \"./util/util\"\n\n// Lazily construct a directory of modules inside which all build steps are performed.\n\nconst buildDirRelPath = join(GARDEN_DIR_NAME, \"build\")\n\nexport class BuildDir {\n  constructor(private projectRoot: string, public buildDirPath: string) { }\n\n  static async factory(projectRoot: string) {\n    const buildDirPath = join(projectRoot, buildDirRelPath)\n    await ensureDir(buildDirPath)\n    return new BuildDir(projectRoot, buildDirPath)\n  }\n\n  async syncFromSrc(module: Module) {\n    await this.sync(\n      resolve(this.projectRoot, module.path) + sep,\n      await this.buildPath(module.name),\n    )\n  }\n\n  async syncDependencyProducts(module: Module) {\n    await this.syncFromSrc(module)\n    const buildPath = await this.buildPath(module.name)\n    const buildDependencies = await module.build.dependencies\n    const dependencyConfigs = module.build.dependencies || []\n\n    await bluebirdMap(zip(buildDependencies, dependencyConfigs), async ([sourceModule, depConfig]) => {\n      if (!sourceModule || !depConfig || !depConfig.copy) {\n        return\n      }\n\n      const sourceBuildPath = await this.buildPath(getModuleKey(sourceModule.name, sourceModule.plugin))\n\n      // Sync to the module's top-level dir by default.\n      await bluebirdMap(depConfig.copy, (copy: BuildCopySpec) => {\n        if (isAbsolute(copy.source)) {\n          throw new ConfigurationError(`Source path in build dependency copy spec must be a relative path`, {\n            copySpec: copy,\n          })\n        }\n\n        if (isAbsolute(copy.target)) {\n          throw new ConfigurationError(`Target path in build dependency copy spec must be a relative path`, {\n            copySpec: copy,\n          })\n        }\n\n        const sourcePath = join(sourceBuildPath, copy.source)\n        const destinationPath = join(buildPath, copy.target)\n        return this.sync(sourcePath, destinationPath)\n      })\n    })\n  }\n\n  async clear() {\n    await emptyDir(this.buildDirPath)\n  }\n\n  async buildPath(moduleName: string): Promise<string> {\n    const path = resolve(this.buildDirPath, moduleName)\n    await ensureDir(path)\n    return path\n  }\n\n  private async sync(sourcePath: string, destinationPath: string): Promise<void> {\n    const destinationDir = parse(destinationPath).dir\n    await ensureDir(destinationDir)\n\n    if (platform() === \"win32\") {\n      // this is so that the cygwin-based rsync client can deal with the paths\n      sourcePath = toCygwinPath(sourcePath)\n      destinationPath = toCygwinPath(destinationPath)\n    }\n\n    // the correct way to copy all contents of a folder is using a trailing slash and not a wildcard\n    sourcePath = stripWildcard(sourcePath)\n    destinationPath = stripWildcard(destinationPath)\n\n    await execa(\"rsync\", [\"-rptgo\", sourcePath, destinationPath])\n  }\n}\n\nfunction stripWildcard(path: string) {\n  return path.endsWith(\"/*\") ? path.slice(0, -1) : path\n}\n"]} diff --git a/garden-service/build/cache.d.ts b/garden-service/build/cache.d.ts new file mode 100644 index 00000000000..6ff4412c029 --- /dev/null +++ b/garden-service/build/cache.d.ts @@ -0,0 +1,68 @@ +export declare type CacheKey = string[]; +export declare type CacheContext = string[]; +export declare type CurriedKey = string; +export declare type CacheValue = string | number | boolean | null | object; +export declare type CacheValues = Map; +/** + * A simple in-memory cache that additionally indexes keys in a tree by a seperate context key, so that keys + * can be invalidated based on surrounding context. + * + * For example, we can cache the version of a directory path, and then invalidate every cached key under a + * parent path: + * + * ``` + * const cache = new TreeCache() + * + * # The context parameter (last parameter) here is the path to the module source + * cache.set(["modules", "my-module-a"], module, ["modules", "module-path-a"]) + * cache.set(["modules", "my-module-b"], module, ["modules", "module-path-b"]) + * + * # Invalidates the cache for module-a + * cache.invalidate(["modules", "module-path-a"]) + * + * # Also invalidates the cache for module-a + * cache.invalidateUp(["modules", "module-path-a", "subdirectory"]) + * + * # Invalidates the cache for both modules + * cache.invalidateDown(["modules"]) + * ``` + * + * This is useful, for example, when listening for filesystem events to make sure cached items stay in + * sync after making changes to sources. + * + * A single cache entry can also have multiple invalidation contexts, which is helpful when a cache key + * can be invalidated by changes to multiple contexts (say for a module version, which should also be + * invalidated when dependencies are updated). + * + */ +export declare class TreeCache { + private readonly cache; + private readonly contextTree; + constructor(); + set(key: CacheKey, value: CacheValue, ...contexts: CacheContext[]): void; + get(key: CacheKey): CacheValue | undefined; + getOrThrow(key: CacheKey): CacheValue; + getByContext(context: CacheContext): CacheValues; + /** + * Delete a specific entry from the cache. + */ + delete(key: CacheKey): void; + /** + * Invalidates all cache entries whose context equals `context` + */ + invalidate(context: CacheContext): void; + /** + * Invalidates all cache entries where the given `context` starts with the entries' context + * (i.e. the whole path from the tree root down to the context leaf) + */ + invalidateUp(context: CacheContext): void; + /** + * Invalidates all cache entries whose context _starts_ with the given `context` + * (i.e. the context node and the whole tree below it) + */ + invalidateDown(context: CacheContext): void; + private getNode; + private clearNode; +} +export declare function pathToCacheContext(path: string): CacheContext; +//# sourceMappingURL=cache.d.ts.map \ No newline at end of file diff --git a/garden-service/build/cache.js b/garden-service/build/cache.js new file mode 100644 index 00000000000..e71b3e1a31f --- /dev/null +++ b/garden-service/build/cache.js @@ -0,0 +1,213 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const path_1 = require("path"); +const exceptions_1 = require("./exceptions"); +/** + * A simple in-memory cache that additionally indexes keys in a tree by a seperate context key, so that keys + * can be invalidated based on surrounding context. + * + * For example, we can cache the version of a directory path, and then invalidate every cached key under a + * parent path: + * + * ``` + * const cache = new TreeCache() + * + * # The context parameter (last parameter) here is the path to the module source + * cache.set(["modules", "my-module-a"], module, ["modules", "module-path-a"]) + * cache.set(["modules", "my-module-b"], module, ["modules", "module-path-b"]) + * + * # Invalidates the cache for module-a + * cache.invalidate(["modules", "module-path-a"]) + * + * # Also invalidates the cache for module-a + * cache.invalidateUp(["modules", "module-path-a", "subdirectory"]) + * + * # Invalidates the cache for both modules + * cache.invalidateDown(["modules"]) + * ``` + * + * This is useful, for example, when listening for filesystem events to make sure cached items stay in + * sync after making changes to sources. + * + * A single cache entry can also have multiple invalidation contexts, which is helpful when a cache key + * can be invalidated by changes to multiple contexts (say for a module version, which should also be + * invalidated when dependencies are updated). + * + */ +class TreeCache { + constructor() { + this.cache = new Map(); + this.contextTree = makeContextNode([]); + } + set(key, value, ...contexts) { + if (key.length === 0) { + throw new exceptions_1.ParameterError(`Cache key must have at least one part`, { key, contexts }); + } + if (contexts.length === 0) { + throw new exceptions_1.ParameterError(`Must specify at least one context`, { key, contexts }); + } + const curriedKey = curry(key); + let entry = this.cache.get(curriedKey); + if (entry === undefined) { + entry = { key, value, contexts: {} }; + this.cache.set(curriedKey, entry); + } + else { + // merge with the existing entry + entry.value = value; + } + contexts.forEach(c => entry.contexts[curry(c)] = c); + for (const context of Object.values(contexts)) { + let node = this.contextTree; + if (context.length === 0) { + throw new exceptions_1.ParameterError(`Context key must have at least one part`, { key, context }); + } + const contextKey = []; + for (const part of context) { + contextKey.push(part); + if (node.children[part]) { + node = node.children[part]; + } + else { + node = node.children[part] = makeContextNode(contextKey); + } + } + node.entries.add(curriedKey); + } + } + get(key) { + const entry = this.cache.get(curry(key)); + return entry ? entry.value : undefined; + } + getOrThrow(key) { + const value = this.get(key); + if (value === undefined) { + throw new exceptions_1.NotFoundError(`Could not find key ${key} in cache`, { key }); + } + return value; + } + getByContext(context) { + let pairs = []; + const node = this.getNode(context); + if (node) { + pairs = Array.from(node.entries).map(curriedKey => { + const entry = this.cache.get(curriedKey); + if (!entry) { + throw new exceptions_1.InternalError(`Invalid reference found in cache: ${curriedKey}`, { curriedKey }); + } + return [entry.key, entry.value]; + }); + } + return new Map(pairs); + } + /** + * Delete a specific entry from the cache. + */ + delete(key) { + const curriedKey = curry(key); + const entry = this.cache.get(curriedKey); + if (entry === undefined) { + return; + } + this.cache.delete(curriedKey); + // clear the entry from its contexts + for (const context of Object.values(entry.contexts)) { + const node = this.getNode(context); + node && node.entries.delete(curriedKey); + } + } + /** + * Invalidates all cache entries whose context equals `context` + */ + invalidate(context) { + const node = this.getNode(context); + if (node) { + // clear all cache entries on the node + this.clearNode(node, false); + } + } + /** + * Invalidates all cache entries where the given `context` starts with the entries' context + * (i.e. the whole path from the tree root down to the context leaf) + */ + invalidateUp(context) { + let node = this.contextTree; + for (const part of context) { + node = node.children[part]; + if (!node) { + break; + } + this.clearNode(node, false); + } + } + /** + * Invalidates all cache entries whose context _starts_ with the given `context` + * (i.e. the context node and the whole tree below it) + */ + invalidateDown(context) { + const node = this.getNode(context); + if (node) { + // clear all cache entries in the node and recursively through all child nodes + this.clearNode(node, true); + } + } + getNode(context) { + let node = this.contextTree; + for (const part of context) { + node = node.children[part]; + if (!node) { + // no cache keys under the given context + return; + } + } + return node; + } + clearNode(node, clearChildNodes) { + for (const curriedKey of node.entries) { + const entry = this.cache.get(curriedKey); + if (entry === undefined) { + return; + } + // also clear the invalidated entry from its other contexts + for (const context of Object.values(entry.contexts)) { + if (!lodash_1.isEqual(context, node.key)) { + const otherNode = this.getNode(context); + otherNode && otherNode.entries.delete(curriedKey); + } + } + this.cache.delete(curriedKey); + } + node.entries = new Set(); + if (clearChildNodes) { + for (const child of Object.values(node.children)) { + this.clearNode(child, true); + } + } + } +} +exports.TreeCache = TreeCache; +function makeContextNode(key) { + return { + key, + children: {}, + entries: new Set(), + }; +} +function curry(key) { + return JSON.stringify(key); +} +function pathToCacheContext(path) { + const parsed = path_1.parse(path_1.normalize(path)); + return ["path", ...parsed.dir.split(path_1.sep)]; +} +exports.pathToCacheContext = pathToCacheContext; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["cache.ts"],"names":[],"mappings":"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","file":"cache.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport {\n  isEqual,\n} from \"lodash\"\nimport {\n  normalize,\n  parse,\n  sep,\n} from \"path\"\nimport {\n  InternalError,\n  NotFoundError,\n  ParameterError,\n} from \"./exceptions\"\n\nexport type CacheKey = string[]\nexport type CacheContext = string[]\nexport type CurriedKey = string\n\nexport type CacheValue = string | number | boolean | null | object\nexport type CacheValues = Map<CacheKey, CacheValue>\n\ninterface CacheEntry {\n  key: CacheKey\n  value: CacheValue\n  contexts: { [curriedContext: string]: CacheContext }\n}\n\ntype CacheEntries = Map<CurriedKey, CacheEntry>\n\ninterface ContextNode {\n  key: CacheContext\n  children: { [contextPart: string]: ContextNode }\n  entries: Set<CurriedKey>\n}\n\n/**\n *  A simple in-memory cache that additionally indexes keys in a tree by a seperate context key, so that keys\n *  can be invalidated based on surrounding context.\n *\n *  For example, we can cache the version of a directory path, and then invalidate every cached key under a\n *  parent path:\n *\n *  ```\n *  const cache = new TreeCache()\n *\n *  # The context parameter (last parameter) here is the path to the module source\n *  cache.set([\"modules\", \"my-module-a\"], module, [\"modules\", \"module-path-a\"])\n *  cache.set([\"modules\", \"my-module-b\"], module, [\"modules\", \"module-path-b\"])\n *\n *  # Invalidates the cache for module-a\n *  cache.invalidate([\"modules\", \"module-path-a\"])\n *\n *  # Also invalidates the cache for module-a\n *  cache.invalidateUp([\"modules\", \"module-path-a\", \"subdirectory\"])\n *\n *  # Invalidates the cache for both modules\n *  cache.invalidateDown([\"modules\"])\n *  ```\n *\n *  This is useful, for example, when listening for filesystem events to make sure cached items stay in\n *  sync after making changes to sources.\n *\n *  A single cache entry can also have multiple invalidation contexts, which is helpful when a cache key\n *  can be invalidated by changes to multiple contexts (say for a module version, which should also be\n *  invalidated when dependencies are updated).\n *\n */\nexport class TreeCache {\n  private readonly cache: CacheEntries\n  private readonly contextTree: ContextNode\n\n  constructor() {\n    this.cache = new Map<CurriedKey, CacheEntry>()\n    this.contextTree = makeContextNode([])\n  }\n\n  set(key: CacheKey, value: CacheValue, ...contexts: CacheContext[]) {\n    if (key.length === 0) {\n      throw new ParameterError(`Cache key must have at least one part`, { key, contexts })\n    }\n\n    if (contexts.length === 0) {\n      throw new ParameterError(`Must specify at least one context`, { key, contexts })\n    }\n\n    const curriedKey = curry(key)\n    let entry = this.cache.get(curriedKey)\n\n    if (entry === undefined) {\n      entry = { key, value, contexts: {} }\n      this.cache.set(curriedKey, entry)\n    } else {\n      // merge with the existing entry\n      entry.value = value\n    }\n\n    contexts.forEach(c => entry!.contexts[curry(c)] = c)\n\n    for (const context of Object.values(contexts)) {\n      let node = this.contextTree\n\n      if (context.length === 0) {\n        throw new ParameterError(`Context key must have at least one part`, { key, context })\n      }\n\n      const contextKey: CacheContext = []\n\n      for (const part of context) {\n        contextKey.push(part)\n\n        if (node.children[part]) {\n          node = node.children[part]\n        } else {\n          node = node.children[part] = makeContextNode(contextKey)\n        }\n      }\n\n      node.entries.add(curriedKey)\n    }\n  }\n\n  get(key: CacheKey): CacheValue | undefined {\n    const entry = this.cache.get(curry(key))\n    return entry ? entry.value : undefined\n  }\n\n  getOrThrow(key: CacheKey): CacheValue {\n    const value = this.get(key)\n    if (value === undefined) {\n      throw new NotFoundError(`Could not find key ${key} in cache`, { key })\n    }\n    return value\n  }\n\n  getByContext(context: CacheContext): CacheValues {\n    let pairs: [CacheKey, CacheValue][] = []\n\n    const node = this.getNode(context)\n\n    if (node) {\n      pairs = Array.from(node.entries).map(curriedKey => {\n        const entry = this.cache.get(curriedKey)\n        if (!entry) {\n          throw new InternalError(`Invalid reference found in cache: ${curriedKey}`, { curriedKey })\n        }\n        return <[CacheKey, CacheValue]>[entry.key, entry.value]\n      })\n    }\n\n    return new Map<CacheKey, CacheValue>(pairs)\n  }\n\n  /**\n   * Delete a specific entry from the cache.\n   */\n  delete(key: CacheKey) {\n    const curriedKey = curry(key)\n    const entry = this.cache.get(curriedKey)\n\n    if (entry === undefined) {\n      return\n    }\n\n    this.cache.delete(curriedKey)\n\n    // clear the entry from its contexts\n    for (const context of Object.values(entry.contexts)) {\n      const node = this.getNode(context)\n      node && node.entries.delete(curriedKey)\n    }\n  }\n\n  /**\n   * Invalidates all cache entries whose context equals `context`\n   */\n  invalidate(context: CacheContext) {\n    const node = this.getNode(context)\n\n    if (node) {\n      // clear all cache entries on the node\n      this.clearNode(node, false)\n    }\n  }\n\n  /**\n   * Invalidates all cache entries where the given `context` starts with the entries' context\n   * (i.e. the whole path from the tree root down to the context leaf)\n   */\n  invalidateUp(context: CacheContext) {\n    let node = this.contextTree\n\n    for (const part of context) {\n      node = node.children[part]\n      if (!node) {\n        break\n      }\n      this.clearNode(node, false)\n    }\n  }\n\n  /**\n   * Invalidates all cache entries whose context _starts_ with the given `context`\n   * (i.e. the context node and the whole tree below it)\n   */\n  invalidateDown(context: CacheContext) {\n    const node = this.getNode(context)\n\n    if (node) {\n      // clear all cache entries in the node and recursively through all child nodes\n      this.clearNode(node, true)\n    }\n  }\n\n  private getNode(context: CacheContext) {\n    let node = this.contextTree\n\n    for (const part of context) {\n      node = node.children[part]\n\n      if (!node) {\n        // no cache keys under the given context\n        return\n      }\n    }\n\n    return node\n  }\n\n  private clearNode(node: ContextNode, clearChildNodes: boolean) {\n    for (const curriedKey of node.entries) {\n      const entry = this.cache.get(curriedKey)\n\n      if (entry === undefined) {\n        return\n      }\n\n      // also clear the invalidated entry from its other contexts\n      for (const context of Object.values(entry.contexts)) {\n        if (!isEqual(context, node.key)) {\n          const otherNode = this.getNode(context)\n          otherNode && otherNode.entries.delete(curriedKey)\n        }\n      }\n\n      this.cache.delete(curriedKey)\n    }\n\n    node.entries = new Set<CurriedKey>()\n\n    if (clearChildNodes) {\n      for (const child of Object.values(node.children)) {\n        this.clearNode(child, true)\n      }\n    }\n  }\n}\n\nfunction makeContextNode(key: CacheContext): ContextNode {\n  return {\n    key,\n    children: {},\n    entries: new Set<CurriedKey>(),\n  }\n}\n\nfunction curry(key: CacheKey | CacheContext) {\n  return JSON.stringify(key)\n}\n\nexport function pathToCacheContext(path: string): CacheContext {\n  const parsed = parse(normalize(path))\n  return [\"path\", ...parsed.dir.split(sep)]\n}\n"]} diff --git a/garden-service/build/cli/cli.d.ts b/garden-service/build/cli/cli.d.ts new file mode 100644 index 00000000000..fd6d91b967c --- /dev/null +++ b/garden-service/build/cli/cli.d.ts @@ -0,0 +1,28 @@ +import { BooleanParameter, Command, ChoicesParameter, Parameter, StringParameter, EnvironmentOption } from "../commands/base"; +import { GardenError } from "../exceptions"; +import { GardenConfig } from "../config/base"; +export declare const MOCK_CONFIG: GardenConfig; +export declare const GLOBAL_OPTIONS: { + root: StringParameter; + silent: BooleanParameter; + env: EnvironmentOption; + loglevel: ChoicesParameter; + output: ChoicesParameter; +}; +export interface ParseResults { + argv: any; + code: number; + errors: (GardenError | Error)[]; +} +export declare class GardenCli { + program: any; + commands: { + [key: string]: Command; + }; + constructor(); + addGlobalOption(key: string, option: Parameter): void; + addCommand(command: Command, program: any): void; + parse(): Promise; +} +export declare function run(): Promise; +//# sourceMappingURL=cli.d.ts.map \ No newline at end of file diff --git a/garden-service/build/cli/cli.js b/garden-service/build/cli/cli.js new file mode 100644 index 00000000000..17eeb036b22 --- /dev/null +++ b/garden-service/build/cli/cli.js @@ -0,0 +1,281 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const sywac = require("sywac"); +const lodash_1 = require("lodash"); +const path_1 = require("path"); +const js_yaml_1 = require("js-yaml"); +const commands_1 = require("../commands/commands"); +const stringify = require("json-stringify-safe"); +const util_1 = require("../util/util"); +const base_1 = require("../commands/base"); +const exceptions_1 = require("../exceptions"); +const garden_1 = require("../garden"); +const logger_1 = require("../logger/logger"); +const log_node_1 = require("../logger/log-node"); +const basic_terminal_writer_1 = require("../logger/writers/basic-terminal-writer"); +const fancy_terminal_writer_1 = require("../logger/writers/fancy-terminal-writer"); +const file_writer_1 = require("../logger/writers/file-writer"); +const helpers_1 = require("./helpers"); +const project_1 = require("../config/project"); +const constants_1 = require("../constants"); +const OUTPUT_RENDERERS = { + json: (data) => { + return stringify(data, null, 2); + }, + yaml: (data) => { + return js_yaml_1.safeDump(data, { noRefs: true, skipInvalid: true }); + }, +}; +const logLevelKeys = util_1.getEnumKeys(log_node_1.LogLevel); +// Allow string or numeric log levels +const logLevelChoices = [...logLevelKeys, ...lodash_1.range(logLevelKeys.length).map(String)]; +const getLogLevelFromArg = (level) => { + const lvl = parseInt(level, 10); + if (lvl) { + return lvl; + } + return log_node_1.LogLevel[level]; +}; +// For initializing garden without a project config +exports.MOCK_CONFIG = { + version: "0", + dirname: "/", + path: process.cwd(), + project: { + name: "mock-project", + defaultEnvironment: "local", + environments: project_1.defaultEnvironments, + environmentDefaults: { + providers: [ + { + name: "local-kubernetes", + }, + ], + variables: {}, + }, + }, +}; +exports.GLOBAL_OPTIONS = { + root: new base_1.StringParameter({ + alias: "r", + help: "Override project root directory (defaults to working directory).", + defaultValue: process.cwd(), + }), + silent: new base_1.BooleanParameter({ + alias: "s", + help: "Suppress log output.", + defaultValue: false, + }), + env: new base_1.EnvironmentOption(), + loglevel: new base_1.ChoicesParameter({ + alias: "l", + choices: logLevelChoices, + help: "Set logger level. Values can be either string or numeric and are prioritized from 0 to 5 " + + "(highest to lowest) as follows: error: 0, warn: 1, info: 2, verbose: 3, debug: 4, silly: 5", + hints: "[enum] [default: info] [error || 0, warn || 1, info || 2, verbose || 3, debug || 4, silly || 5]", + defaultValue: log_node_1.LogLevel[log_node_1.LogLevel.info], + }), + output: new base_1.ChoicesParameter({ + alias: "o", + choices: Object.keys(OUTPUT_RENDERERS), + help: "Output command result in specified format (note: disables progress logging).", + }), +}; +const GLOBAL_OPTIONS_GROUP_NAME = "Global options"; +const DEFAULT_CLI_LOGGER_TYPE = logger_1.LoggerType.fancy; +class GardenCli { + constructor() { + this.commands = {}; + const version = require("../../package.json").version; + this.program = sywac + .help("-h, --help", { + group: GLOBAL_OPTIONS_GROUP_NAME, + implicitCommand: false, + }) + .version("-v, --version", { + version, + group: GLOBAL_OPTIONS_GROUP_NAME, + implicitCommand: false, + }) + .showHelpByDefault() + .check((argv, _ctx) => { + // NOTE: Need to mutate argv! + lodash_1.merge(argv, helpers_1.falsifyConflictingParams(argv, exports.GLOBAL_OPTIONS)); + }) + .style(helpers_1.styleConfig); + const commands = commands_1.coreCommands; + const globalOptions = Object.entries(exports.GLOBAL_OPTIONS); + commands.forEach(command => this.addCommand(command, this.program)); + globalOptions.forEach(([key, opt]) => this.addGlobalOption(key, opt)); + } + addGlobalOption(key, option) { + this.program.option(helpers_1.getOptionSynopsis(key, option), Object.assign({}, helpers_1.prepareOptionConfig(option), { group: GLOBAL_OPTIONS_GROUP_NAME })); + } + addCommand(command, program) { + const fullName = command.getFullName(); + if (this.commands[fullName]) { + // For now we don't allow multiple definitions of the same command. We may want to revisit this later. + throw new exceptions_1.PluginError(`Multiple definitions of command "${fullName}"`, {}); + } + this.commands[fullName] = command; + const { arguments: args = {}, loggerType = DEFAULT_CLI_LOGGER_TYPE, options = {}, subCommands, } = command; + const argKeys = helpers_1.getKeys(args); + const optKeys = helpers_1.getKeys(options); + const globalKeys = helpers_1.getKeys(exports.GLOBAL_OPTIONS); + const dupKeys = lodash_1.intersection(optKeys, globalKeys); + if (dupKeys.length > 0) { + throw new exceptions_1.PluginError(`Global option(s) ${dupKeys.join(" ")} cannot be redefined`, {}); + } + const action = (argv, cliContext) => __awaiter(this, void 0, void 0, function* () { + // Sywac returns positional args and options in a single object which we separate into args and opts + const parsedArgs = helpers_1.filterByKeys(argv, argKeys); + const parsedOpts = helpers_1.filterByKeys(argv, optKeys.concat(globalKeys)); + const root = path_1.resolve(process.cwd(), parsedOpts.root); + const { env, loglevel, silent, output } = parsedOpts; + // Init logger + const level = getLogLevelFromArg(loglevel); + let writers = []; + if (!silent && !output && loggerType !== logger_1.LoggerType.quiet) { + if (loggerType === logger_1.LoggerType.fancy) { + writers.push(new fancy_terminal_writer_1.FancyTerminalWriter()); + } + else if (loggerType === logger_1.LoggerType.basic) { + writers.push(new basic_terminal_writer_1.BasicTerminalWriter()); + } + } + const logger = logger_1.Logger.initialize({ level, writers }); + let garden; + let result; + do { + const contextOpts = { env, logger }; + if (command.noProject) { + contextOpts.config = exports.MOCK_CONFIG; + } + garden = yield garden_1.Garden.factory(root, contextOpts); + // TODO: enforce that commands always output DeepPrimitiveMap + result = yield command.action({ + garden, + args: parsedArgs, + opts: parsedOpts, + }); + } while (result.restartRequired); + // We attach the action result to cli context so that we can process it in the parse method + cliContext.details.result = result; + }); + // Command specific positional args and options are set inside the builder function + const setup = parser => { + subCommands.forEach(subCommandCls => this.addCommand(new subCommandCls(command), parser)); + argKeys.forEach(key => parser.positional(helpers_1.getArgSynopsis(key, args[key]), helpers_1.prepareArgConfig(args[key]))); + optKeys.forEach(key => parser.option(helpers_1.getOptionSynopsis(key, options[key]), helpers_1.prepareOptionConfig(options[key]))); + // We only check for invalid flags for the last command since it might contain flags that + // the parent is unaware of, thus causing the check to fail for the parent + if (subCommands.length < 1) { + parser.check(helpers_1.failOnInvalidOptions); + } + return parser; + }; + const commandConfig = { + setup, + aliases: command.alias, + desc: command.help, + run: action, + }; + program.command(command.name, commandConfig); + } + parse() { + return __awaiter(this, void 0, void 0, function* () { + const parseResult = yield this.program.parse(); + const { argv, details, errors, output: cliOutput } = parseResult; + const { result: commandResult } = details; + const { output } = argv; + let { code } = parseResult; + let logger; + // Note: Circumvents an issue where the process exits before the output is fully flushed. + // Needed for output renderers and Winston (see: https://github.com/winstonjs/winston/issues/228) + const waitForOutputFlush = () => util_1.sleep(100); + // Logger might not have been initialised if process exits early + try { + logger = logger_1.getLogger(); + } + catch (_) { + logger = logger_1.Logger.initialize({ + level: log_node_1.LogLevel.info, + writers: [new basic_terminal_writer_1.BasicTerminalWriter()], + }); + } + // --help or --version options were called so we log the cli output and exit + if (cliOutput && errors.length < 1) { + logger.stop(); + console.log(cliOutput); + // fix issue where sywac returns exit code 0 even when a command doesn't exist + if (!argv.h && !argv.help) { + code = 1; + } + process.exit(code); + } + const gardenErrors = errors + .map(exceptions_1.toGardenError) + .concat((commandResult && commandResult.errors) || []); + // --output option set + if (output) { + const renderer = OUTPUT_RENDERERS[output]; + if (gardenErrors.length > 0) { + console.error(renderer({ success: false, errors: gardenErrors })); + } + else { + console.log(renderer(Object.assign({ success: true }, commandResult))); + } + yield waitForOutputFlush(); + } + if (gardenErrors.length > 0) { + gardenErrors.forEach(error => logger.error({ + msg: error.message, + error, + })); + if (logger.writers.find(w => w instanceof file_writer_1.FileWriter)) { + logger.info(`\nSee ${constants_1.ERROR_LOG_FILENAME} for detailed error message`); + yield waitForOutputFlush(); + } + code = 1; + } + logger.stop(); + return { argv, code, errors }; + }); + } +} +exports.GardenCli = GardenCli; +function run() { + return __awaiter(this, void 0, void 0, function* () { + let code; + try { + const cli = new GardenCli(); + const result = yield cli.parse(); + code = result.code; + } + catch (err) { + console.log(err); + code = 1; + } + finally { + util_1.shutdown(code); + } + }); +} +exports.run = run; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["cli/cli.ts"],"names":[],"mappings":"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","file":"cli/cli.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as sywac from \"sywac\"\nimport { merge, intersection, range } from \"lodash\"\nimport { resolve } from \"path\"\nimport { safeDump } from \"js-yaml\"\nimport { coreCommands } from \"../commands/commands\"\nimport stringify = require(\"json-stringify-safe\")\n\nimport { DeepPrimitiveMap } from \"../config/common\"\nimport {\n  getEnumKeys,\n  shutdown,\n  sleep,\n} from \"../util/util\"\nimport {\n  BooleanParameter,\n  Command,\n  ChoicesParameter,\n  Parameter,\n  StringParameter,\n  EnvironmentOption,\n  CommandResult,\n} from \"../commands/base\"\nimport {\n  GardenError,\n  PluginError,\n  toGardenError,\n} from \"../exceptions\"\nimport { Garden, ContextOpts } from \"../garden\"\n\nimport { Logger, LoggerType, getLogger } from \"../logger/logger\"\nimport { LogLevel } from \"../logger/log-node\"\nimport { BasicTerminalWriter } from \"../logger/writers/basic-terminal-writer\"\nimport { FancyTerminalWriter } from \"../logger/writers/fancy-terminal-writer\"\nimport { FileWriter } from \"../logger/writers/file-writer\"\nimport { Writer } from \"../logger/writers/base\"\n\nimport {\n  falsifyConflictingParams,\n  failOnInvalidOptions,\n  getArgSynopsis,\n  getKeys,\n  getOptionSynopsis,\n  filterByKeys,\n  prepareArgConfig,\n  prepareOptionConfig,\n  styleConfig,\n} from \"./helpers\"\nimport { GardenConfig } from \"../config/base\"\nimport { defaultEnvironments } from \"../config/project\"\nimport { ERROR_LOG_FILENAME } from \"../constants\"\n\nconst OUTPUT_RENDERERS = {\n  json: (data: DeepPrimitiveMap) => {\n    return stringify(data, null, 2)\n  },\n  yaml: (data: DeepPrimitiveMap) => {\n    return safeDump(data, { noRefs: true, skipInvalid: true })\n  },\n}\n\nconst logLevelKeys = getEnumKeys(LogLevel)\n// Allow string or numeric log levels\nconst logLevelChoices = [...logLevelKeys, ...range(logLevelKeys.length).map(String)]\n\nconst getLogLevelFromArg = (level: string) => {\n  const lvl = parseInt(level, 10)\n  if (lvl) {\n    return lvl\n  }\n  return LogLevel[level]\n}\n\n// For initializing garden without a project config\nexport const MOCK_CONFIG: GardenConfig = {\n  version: \"0\",\n  dirname: \"/\",\n  path: process.cwd(),\n  project: {\n    name: \"mock-project\",\n    defaultEnvironment: \"local\",\n    environments: defaultEnvironments,\n    environmentDefaults: {\n      providers: [\n        {\n          name: \"local-kubernetes\",\n        },\n      ],\n      variables: {},\n    },\n  },\n}\n\nexport const GLOBAL_OPTIONS = {\n  root: new StringParameter({\n    alias: \"r\",\n    help: \"Override project root directory (defaults to working directory).\",\n    defaultValue: process.cwd(),\n  }),\n  silent: new BooleanParameter({\n    alias: \"s\",\n    help: \"Suppress log output.\",\n    defaultValue: false,\n  }),\n  env: new EnvironmentOption(),\n  loglevel: new ChoicesParameter({\n    alias: \"l\",\n    choices: logLevelChoices,\n    help:\n      \"Set logger level. Values can be either string or numeric and are prioritized from 0 to 5 \" +\n      \"(highest to lowest) as follows: error: 0, warn: 1, info: 2, verbose: 3, debug: 4, silly: 5\",\n    hints:\n      \"[enum] [default: info] [error || 0, warn || 1, info || 2, verbose || 3, debug || 4, silly || 5]\",\n    defaultValue: LogLevel[LogLevel.info],\n  }),\n  output: new ChoicesParameter({\n    alias: \"o\",\n    choices: Object.keys(OUTPUT_RENDERERS),\n    help: \"Output command result in specified format (note: disables progress logging).\",\n  }),\n}\nconst GLOBAL_OPTIONS_GROUP_NAME = \"Global options\"\nconst DEFAULT_CLI_LOGGER_TYPE = LoggerType.fancy\n\nexport interface ParseResults {\n  argv: any\n  code: number\n  errors: (GardenError | Error)[]\n}\n\ninterface SywacParseResults extends ParseResults {\n  output: string\n  details: { logger: Logger, result?: CommandResult }\n}\n\nexport class GardenCli {\n  program: any\n  commands: { [key: string]: Command } = {}\n\n  constructor() {\n    const version = require(\"../../package.json\").version\n    this.program = sywac\n      .help(\"-h, --help\", {\n        group: GLOBAL_OPTIONS_GROUP_NAME,\n        implicitCommand: false,\n      })\n      .version(\"-v, --version\", {\n        version,\n        group: GLOBAL_OPTIONS_GROUP_NAME,\n        implicitCommand: false,\n      })\n      .showHelpByDefault()\n      .check((argv, _ctx) => {\n        // NOTE: Need to mutate argv!\n        merge(argv, falsifyConflictingParams(argv, GLOBAL_OPTIONS))\n      })\n      .style(styleConfig)\n\n    const commands = coreCommands\n\n    const globalOptions = Object.entries(GLOBAL_OPTIONS)\n\n    commands.forEach(command => this.addCommand(command, this.program))\n    globalOptions.forEach(([key, opt]) => this.addGlobalOption(key, opt))\n  }\n\n  addGlobalOption(key: string, option: Parameter<any>): void {\n    this.program.option(getOptionSynopsis(key, option), {\n      ...prepareOptionConfig(option),\n      group: GLOBAL_OPTIONS_GROUP_NAME,\n    })\n  }\n\n  addCommand(command: Command, program): void {\n    const fullName = command.getFullName()\n\n    if (this.commands[fullName]) {\n      // For now we don't allow multiple definitions of the same command. We may want to revisit this later.\n      throw new PluginError(`Multiple definitions of command \"${fullName}\"`, {})\n    }\n\n    this.commands[fullName] = command\n\n    const {\n      arguments: args = {},\n      loggerType = DEFAULT_CLI_LOGGER_TYPE,\n      options = {},\n      subCommands,\n    } = command\n\n    const argKeys = getKeys(args)\n    const optKeys = getKeys(options)\n    const globalKeys = getKeys(GLOBAL_OPTIONS)\n    const dupKeys: string[] = intersection(optKeys, globalKeys)\n\n    if (dupKeys.length > 0) {\n      throw new PluginError(`Global option(s) ${dupKeys.join(\" \")} cannot be redefined`, {})\n    }\n\n    const action = async (argv, cliContext) => {\n      // Sywac returns positional args and options in a single object which we separate into args and opts\n      const parsedArgs = filterByKeys(argv, argKeys)\n      const parsedOpts = filterByKeys(argv, optKeys.concat(globalKeys))\n      const root = resolve(process.cwd(), parsedOpts.root)\n      const { env, loglevel, silent, output } = parsedOpts\n\n      // Init logger\n      const level = getLogLevelFromArg(loglevel)\n      let writers: Writer[] = []\n\n      if (!silent && !output && loggerType !== LoggerType.quiet) {\n        if (loggerType === LoggerType.fancy) {\n          writers.push(new FancyTerminalWriter())\n        } else if (loggerType === LoggerType.basic) {\n          writers.push(new BasicTerminalWriter())\n        }\n      }\n\n      const logger = Logger.initialize({ level, writers })\n      let garden: Garden\n      let result\n      do {\n        const contextOpts: ContextOpts = { env, logger }\n        if (command.noProject) {\n          contextOpts.config = MOCK_CONFIG\n        }\n        garden = await Garden.factory(root, contextOpts)\n        // TODO: enforce that commands always output DeepPrimitiveMap\n        result = await command.action({\n          garden,\n          args: parsedArgs,\n          opts: parsedOpts,\n        })\n      } while (result.restartRequired)\n\n      // We attach the action result to cli context so that we can process it in the parse method\n      cliContext.details.result = result\n    }\n\n    // Command specific positional args and options are set inside the builder function\n    const setup = parser => {\n      subCommands.forEach(subCommandCls => this.addCommand(new subCommandCls(command), parser))\n      argKeys.forEach(key => parser.positional(getArgSynopsis(key, args[key]), prepareArgConfig(args[key])))\n      optKeys.forEach(key => parser.option(getOptionSynopsis(key, options[key]), prepareOptionConfig(options[key])))\n\n      // We only check for invalid flags for the last command since it might contain flags that\n      // the parent is unaware of, thus causing the check to fail for the parent\n      if (subCommands.length < 1) {\n        parser.check(failOnInvalidOptions)\n      }\n      return parser\n    }\n\n    const commandConfig = {\n      setup,\n      aliases: command.alias,\n      desc: command.help,\n      run: action,\n    }\n\n    program.command(command.name, commandConfig)\n  }\n\n  async parse(): Promise<ParseResults> {\n    const parseResult: SywacParseResults = await this.program.parse()\n    const { argv, details, errors, output: cliOutput } = parseResult\n    const { result: commandResult } = details\n    const { output } = argv\n    let { code } = parseResult\n    let logger: Logger\n\n    // Note: Circumvents an issue where the process exits before the output is fully flushed.\n    // Needed for output renderers and Winston (see: https://github.com/winstonjs/winston/issues/228)\n    const waitForOutputFlush = () => sleep(100)\n\n    // Logger might not have been initialised if process exits early\n    try {\n      logger = getLogger()\n    } catch (_) {\n      logger = Logger.initialize({\n        level: LogLevel.info,\n        writers: [new BasicTerminalWriter()],\n      })\n    }\n\n    // --help or --version options were called so we log the cli output and exit\n    if (cliOutput && errors.length < 1) {\n      logger.stop()\n      console.log(cliOutput)\n\n      // fix issue where sywac returns exit code 0 even when a command doesn't exist\n      if (!argv.h && !argv.help) {\n        code = 1\n      }\n\n      process.exit(code)\n    }\n\n    const gardenErrors: GardenError[] = errors\n      .map(toGardenError)\n      .concat((commandResult && commandResult.errors) || [])\n\n    // --output option set\n    if (output) {\n      const renderer = OUTPUT_RENDERERS[output]\n      if (gardenErrors.length > 0) {\n        console.error(renderer({ success: false, errors: gardenErrors }))\n      } else {\n        console.log(renderer({ success: true, ...commandResult }))\n      }\n      await waitForOutputFlush()\n    }\n\n    if (gardenErrors.length > 0) {\n      gardenErrors.forEach(error => logger.error({\n        msg: error.message,\n        error,\n      }))\n\n      if (logger.writers.find(w => w instanceof FileWriter)) {\n        logger.info(`\\nSee ${ERROR_LOG_FILENAME} for detailed error message`)\n        await waitForOutputFlush()\n      }\n\n      code = 1\n    }\n\n    logger.stop()\n    return { argv, code, errors }\n  }\n\n}\n\nexport async function run(): Promise<void> {\n  let code\n  try {\n    const cli = new GardenCli()\n    const result = await cli.parse()\n    code = result.code\n  } catch (err) {\n    console.log(err)\n    code = 1\n  } finally {\n    shutdown(code)\n  }\n}\n"]} diff --git a/garden-service/build/cli/helpers.d.ts b/garden-service/build/cli/helpers.d.ts new file mode 100644 index 00000000000..a993a259090 --- /dev/null +++ b/garden-service/build/cli/helpers.d.ts @@ -0,0 +1,45 @@ +import { ParameterValues, Parameter } from "../commands/base"; +export declare const styleConfig: { + usagePrefix: (str: any) => string; + usageCommandPlaceholder: (str: any) => string; + usagePositionals: (str: any) => string; + usageArgsPlaceholder: (str: any) => string; + usageOptionsPlaceholder: (str: any) => string; + group: (str: string) => string; + flags: (str: any, _type: any) => string; + hints: (str: any) => string; + groupError: (str: any) => string; + flagsError: (str: any) => string; + descError: (str: any) => string; + hintsError: (str: any) => string; + messages: (str: any) => string; +}; +export declare const getKeys: (obj: any) => string[]; +export declare const filterByKeys: (obj: any, keys: string[]) => any; +export declare type FalsifiedParams = { + [key: string]: false; +}; +/** + * Returns the params that need to be overridden set to false + */ +export declare function falsifyConflictingParams(argv: any, params: ParameterValues): FalsifiedParams; +export declare function getOptionSynopsis(key: string, { alias }: Parameter): string; +export declare function getArgSynopsis(key: string, param: Parameter): string; +export declare function prepareArgConfig(param: Parameter): { + desc: string; + params: SywacOptionConfig[]; +}; +export interface SywacOptionConfig { + desc: string | string[]; + type: string; + defaultValue?: any; + coerce?: Function; + choices?: any[]; + required?: boolean; + hints?: string; + strict: true; + mustExist: true; +} +export declare function prepareOptionConfig(param: Parameter): SywacOptionConfig; +export declare function failOnInvalidOptions(argv: any, ctx: any): void; +//# sourceMappingURL=helpers.d.ts.map \ No newline at end of file diff --git a/garden-service/build/cli/helpers.js b/garden-service/build/cli/helpers.js new file mode 100644 index 00000000000..821aa57bdf9 --- /dev/null +++ b/garden-service/build/cli/helpers.js @@ -0,0 +1,133 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const chalk_1 = require("chalk"); +const lodash_1 = require("lodash"); +const exceptions_1 = require("../exceptions"); +// Parameter types T which map between the Parameter class and the Sywac cli library. +// In case we add types that aren't supported natively by Sywac, see: http://sywac.io/docs/sync-config.html#custom +const VALID_PARAMETER_TYPES = ["boolean", "number", "choice", "string", "array:string", "path", "array:path"]; +exports.styleConfig = { + usagePrefix: str => (` +${chalk_1.default.bold(str.slice(0, 5).toUpperCase())} + ${chalk_1.default.italic(str.slice(7))}`), + usageCommandPlaceholder: str => chalk_1.default.blue(str), + usagePositionals: str => chalk_1.default.magenta(str), + usageArgsPlaceholder: str => chalk_1.default.magenta(str), + usageOptionsPlaceholder: str => chalk_1.default.yellow(str), + group: (str) => { + const cleaned = str.endsWith(":") ? str.slice(0, -1) : str; + return chalk_1.default.bold(cleaned.toUpperCase()); + }, + flags: (str, _type) => { + const style = str.startsWith("-") ? chalk_1.default.green : chalk_1.default.magenta; + return style(str); + }, + hints: str => chalk_1.default.gray(str), + groupError: str => chalk_1.default.red.bold(str), + flagsError: str => chalk_1.default.red.bold(str), + descError: str => chalk_1.default.yellow.bold(str), + hintsError: str => chalk_1.default.red(str), + messages: str => chalk_1.default.red.bold(str), +}; +// Helper functions +exports.getKeys = (obj) => Object.keys(obj || {}); +exports.filterByKeys = (obj, keys) => { + return keys.reduce((memo, key) => { + if (obj[key]) { + memo[key] = obj[key]; + } + return memo; + }, {}); +}; +/** + * Returns the params that need to be overridden set to false + */ +function falsifyConflictingParams(argv, params) { + return lodash_1.reduce(argv, (acc, val, key) => { + const param = params[key]; + const overrides = (param || {}).overrides || []; + // argv always contains the "_" key which is irrelevant here + if (key === "_" || !param || !val || !(overrides.length > 0)) { + return acc; + } + const withAliases = overrides.reduce((_, keyToOverride) => { + if (!params[keyToOverride]) { + throw new exceptions_1.InternalError(`Cannot override non-existing parameter: ${keyToOverride}`, { + keyToOverride, + availableKeys: Object.keys(params), + }); + } + return [keyToOverride, ...params[keyToOverride].alias]; + }, []); + withAliases.forEach(keyToOverride => acc[keyToOverride] = false); + return acc; + }, {}); +} +exports.falsifyConflictingParams = falsifyConflictingParams; +// Sywac specific transformers and helpers +function getOptionSynopsis(key, { alias }) { + if (alias && alias.length > 1) { + throw new exceptions_1.InternalError("Option aliases can only be a single character", { + optionName: key, + alias, + }); + } + return alias ? `-${alias}, --${key}` : `--${key}`; +} +exports.getOptionSynopsis = getOptionSynopsis; +function getArgSynopsis(key, param) { + return param.required ? `<${key}>` : `[${key}]`; +} +exports.getArgSynopsis = getArgSynopsis; +function prepareArgConfig(param) { + return { + desc: param.help, + params: [prepareOptionConfig(param)], + }; +} +exports.prepareArgConfig = prepareArgConfig; +function prepareOptionConfig(param) { + const { coerce, defaultValue, help: desc, hints, required, type, } = param; + if (!VALID_PARAMETER_TYPES.includes(type)) { + throw new exceptions_1.InternalError(`Invalid parameter type for cli: ${type}`, { + type, + validParameterTypes: VALID_PARAMETER_TYPES, + }); + } + let config = { + coerce, + defaultValue, + desc, + required, + type, + hints, + strict: true, + mustExist: true, + }; + if (type === "choice") { + config.type = "enum"; + config.choices = param.choices; + } + return config; +} +exports.prepareOptionConfig = prepareOptionConfig; +function failOnInvalidOptions(argv, ctx) { + const validOptions = lodash_1.flatten(ctx.details.types + .filter(t => t.datatype !== "command") + .map(t => t.aliases)); + const receivedOptions = Object.keys(argv); + const invalid = lodash_1.difference(receivedOptions, validOptions); + if (invalid.length > 0) { + ctx.cliMessage(`Received invalid flag(s): ${invalid.join(", ")}`); + } +} +exports.failOnInvalidOptions = failOnInvalidOptions; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["cli/helpers.ts"],"names":[],"mappings":"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","file":"cli/helpers.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport chalk from \"chalk\"\nimport { difference, flatten, reduce } from \"lodash\"\nimport {\n  ChoicesParameter,\n  ParameterValues,\n  Parameter,\n} from \"../commands/base\"\nimport {\n  InternalError,\n} from \"../exceptions\"\n\n// Parameter types T which map between the Parameter<T> class and the Sywac cli library.\n// In case we add types that aren't supported natively by Sywac, see: http://sywac.io/docs/sync-config.html#custom\nconst VALID_PARAMETER_TYPES = [\"boolean\", \"number\", \"choice\", \"string\", \"array:string\", \"path\", \"array:path\"]\n\nexport const styleConfig = {\n  usagePrefix: str => (\n    `\n${chalk.bold(str.slice(0, 5).toUpperCase())}\n  ${chalk.italic(str.slice(7))}`\n  ),\n  usageCommandPlaceholder: str => chalk.blue(str),\n  usagePositionals: str => chalk.magenta(str),\n  usageArgsPlaceholder: str => chalk.magenta(str),\n  usageOptionsPlaceholder: str => chalk.yellow(str),\n  group: (str: string) => {\n    const cleaned = str.endsWith(\":\") ? str.slice(0, -1) : str\n    return chalk.bold(cleaned.toUpperCase())\n  },\n  flags: (str, _type) => {\n    const style = str.startsWith(\"-\") ? chalk.green : chalk.magenta\n    return style(str)\n  },\n  hints: str => chalk.gray(str),\n  groupError: str => chalk.red.bold(str),\n  flagsError: str => chalk.red.bold(str),\n  descError: str => chalk.yellow.bold(str),\n  hintsError: str => chalk.red(str),\n  messages: str => chalk.red.bold(str), // these are error messages\n}\n\n// Helper functions\nexport const getKeys = (obj): string[] => Object.keys(obj || {})\nexport const filterByKeys = (obj: any, keys: string[]): any => {\n  return keys.reduce((memo, key) => {\n    if (obj[key]) {\n      memo[key] = obj[key]\n    }\n    return memo\n  }, {})\n}\n\nexport type FalsifiedParams = { [key: string]: false }\n\n/**\n * Returns the params that need to be overridden set to false\n */\nexport function falsifyConflictingParams(argv, params: ParameterValues<any>): FalsifiedParams {\n  return reduce(argv, (acc: {}, val: any, key: string) => {\n    const param = params[key]\n    const overrides = (param || {}).overrides || []\n    // argv always contains the \"_\" key which is irrelevant here\n    if (key === \"_\" || !param || !val || !(overrides.length > 0)) {\n      return acc\n    }\n    const withAliases = overrides.reduce((_, keyToOverride: string): string[] => {\n      if (!params[keyToOverride]) {\n        throw new InternalError(`Cannot override non-existing parameter: ${keyToOverride}`, {\n          keyToOverride,\n          availableKeys: Object.keys(params),\n        })\n      }\n      return [keyToOverride, ...params[keyToOverride].alias]\n    }, [])\n\n    withAliases.forEach(keyToOverride => acc[keyToOverride] = false)\n    return acc\n  }, {})\n}\n\n// Sywac specific transformers and helpers\nexport function getOptionSynopsis(key: string, { alias }: Parameter<any>): string {\n  if (alias && alias.length > 1) {\n    throw new InternalError(\"Option aliases can only be a single character\", {\n      optionName: key,\n      alias,\n    })\n  }\n  return alias ? `-${alias}, --${key}` : `--${key}`\n}\n\nexport function getArgSynopsis(key: string, param: Parameter<any>) {\n  return param.required ? `<${key}>` : `[${key}]`\n}\n\nexport function prepareArgConfig(param: Parameter<any>) {\n  return {\n    desc: param.help,\n    params: [prepareOptionConfig(param)],\n  }\n}\n\nexport interface SywacOptionConfig {\n  desc: string | string[]\n  type: string\n  defaultValue?: any\n  coerce?: Function\n  choices?: any[]\n  required?: boolean\n  hints?: string\n  strict: true\n  mustExist: true // For parameters of path type\n}\n\nexport function prepareOptionConfig(param: Parameter<any>): SywacOptionConfig {\n  const {\n    coerce,\n    defaultValue,\n    help: desc,\n    hints,\n    required,\n    type,\n  } = param\n  if (!VALID_PARAMETER_TYPES.includes(type)) {\n    throw new InternalError(`Invalid parameter type for cli: ${type}`, {\n      type,\n      validParameterTypes: VALID_PARAMETER_TYPES,\n    })\n  }\n  let config: SywacOptionConfig = {\n    coerce,\n    defaultValue,\n    desc,\n    required,\n    type,\n    hints,\n    strict: true,\n    mustExist: true, // For parameters of path type\n  }\n  if (type === \"choice\") {\n    config.type = \"enum\"\n    config.choices = (<ChoicesParameter>param).choices\n  }\n  return config\n}\n\nexport function failOnInvalidOptions(argv, ctx) {\n  const validOptions = flatten(\n    ctx.details.types\n      .filter(t => t.datatype !== \"command\")\n      .map(t => t.aliases),\n  )\n  const receivedOptions = Object.keys(argv)\n  const invalid = difference(receivedOptions, validOptions)\n  if (invalid.length > 0) {\n    ctx.cliMessage(`Received invalid flag(s): ${invalid.join(\", \")}`)\n  }\n}\n"]} diff --git a/garden-service/build/commands/base.d.ts b/garden-service/build/commands/base.d.ts new file mode 100644 index 00000000000..b3565509889 --- /dev/null +++ b/garden-service/build/commands/base.d.ts @@ -0,0 +1,156 @@ +import { GardenError } from "../exceptions"; +import { TaskResults } from "../task-graph"; +import { LoggerType } from "../logger/logger"; +import { ProcessResults } from "../process"; +import { Garden } from "../garden"; +export declare class ValidationError extends Error { +} +export interface ParameterConstructor { + help: string; + required?: boolean; + alias?: string; + defaultValue?: T; + valueName?: string; + hints?: string; + overrides?: string[]; +} +export declare abstract class Parameter { + abstract type: string; + _valueType: T; + defaultValue: T | undefined; + help: string; + required: boolean; + alias?: string; + hints?: string; + valueName: string; + overrides: string[]; + constructor({ help, required, alias, defaultValue, valueName, overrides, hints }: ParameterConstructor); + coerce(input: T): T | undefined; + abstract validate(input: string): T; + autoComplete(): Promise; +} +export declare class StringParameter extends Parameter { + type: string; + validate(input: string): string; +} +export declare class StringOption extends Parameter { + type: string; + validate(input?: string): string | undefined; +} +export declare class StringsParameter extends Parameter { + type: string; + coerce(input: string[]): string[] | undefined; + validate(input: string): string[]; +} +export declare class PathParameter extends Parameter { + type: string; + validate(input: string): string; +} +export declare class PathsParameter extends Parameter { + type: string; + validate(input: string): string[]; +} +export declare class NumberParameter extends Parameter { + type: string; + validate(input: string): number; +} +export interface ChoicesConstructor extends ParameterConstructor { + choices: string[]; +} +export declare class ChoicesParameter extends Parameter { + type: string; + choices: string[]; + constructor(args: ChoicesConstructor); + validate(input: string): string; + autoComplete(): Promise; +} +export declare class BooleanParameter extends Parameter { + type: string; + validate(input: any): boolean; +} +export declare class EnvironmentOption extends StringParameter { + constructor({ help }?: { + help?: string | undefined; + }); +} +export declare type Parameters = { + [key: string]: Parameter; +}; +export declare type ParameterValues = { + [P in keyof T]: T[P]["_valueType"]; +}; +export interface CommandConstructor { + new (parent?: Command): Command; +} +export interface CommandResult { + result?: T; + restartRequired?: boolean; + errors?: GardenError[]; +} +export interface CommandParams { + args: ParameterValues; + opts: ParameterValues; + garden: Garden; +} +export declare abstract class Command { + private parent?; + abstract name: string; + abstract help: string; + description?: string; + alias?: string; + loggerType?: LoggerType; + arguments?: T; + options?: U; + noProject: boolean; + subCommands: CommandConstructor[]; + constructor(parent?: Command<{}, {}> | undefined); + getFullName(): any; + describe(): { + name: string; + fullName: any; + help: string; + description: string | undefined; + arguments: { + type: string; + _valueType: any; + defaultValue: any; + help: string; + required: boolean; + alias?: string | undefined; + hints?: string | undefined; + valueName: string; + overrides: string[]; + name: string; + usageName: string; + }[] | undefined; + options: { + type: string; + _valueType: any; + defaultValue: any; + help: string; + required: boolean; + alias?: string | undefined; + hints?: string | undefined; + valueName: string; + overrides: string[]; + name: string; + usageName: string; + }[] | undefined; + }; + abstract action(params: CommandParams): Promise; +} +export declare function handleTaskResults(garden: Garden, taskType: string, results: ProcessResults): Promise>; +export declare function describeParameters(args?: Parameters): { + type: string; + _valueType: any; + defaultValue: any; + help: string; + required: boolean; + alias?: string | undefined; + hints?: string | undefined; + valueName: string; + overrides: string[]; + name: string; + usageName: string; +}[] | undefined; +//# sourceMappingURL=base.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/base.js b/garden-service/build/commands/base.js new file mode 100644 index 00000000000..8115cef9c83 --- /dev/null +++ b/garden-service/build/commands/base.js @@ -0,0 +1,210 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const exceptions_1 = require("../exceptions"); +class ValidationError extends Error { +} +exports.ValidationError = ValidationError; +class Parameter { + constructor({ help, required, alias, defaultValue, valueName, overrides, hints }) { + this.help = help; + this.required = required || false; + this.alias = alias; + this.hints = hints; + this.defaultValue = defaultValue; + this.valueName = valueName || "_valueType"; + this.overrides = overrides || []; + } + coerce(input) { + return input; + } + autoComplete() { + return __awaiter(this, void 0, void 0, function* () { + return []; + }); + } +} +exports.Parameter = Parameter; +class StringParameter extends Parameter { + constructor() { + super(...arguments); + this.type = "string"; + } + validate(input) { + return input; + } +} +exports.StringParameter = StringParameter; +// Separating this from StringParameter for now because we can't set the output type based on the required flag +// FIXME: Maybe use a Required type to enforce presence, rather that an option flag? +class StringOption extends Parameter { + constructor() { + super(...arguments); + this.type = "string"; + } + validate(input) { + return input; + } +} +exports.StringOption = StringOption; +class StringsParameter extends Parameter { + constructor() { + super(...arguments); + this.type = "array:string"; + } + // Sywac returns [undefined] if input is empty so we coerce that into undefined. + // This only applies to optional parameters since Sywac would throw if input is empty for a required parameter. + coerce(input) { + const filtered = input.filter(i => !!i); + if (filtered.length < 1) { + return undefined; + } + return filtered; + } + validate(input) { + return input.split(","); + } +} +exports.StringsParameter = StringsParameter; +class PathParameter extends Parameter { + constructor() { + super(...arguments); + this.type = "path"; + } + validate(input) { + return input; + } +} +exports.PathParameter = PathParameter; +class PathsParameter extends Parameter { + constructor() { + super(...arguments); + this.type = "array:path"; + } + validate(input) { + return input.split(","); + } +} +exports.PathsParameter = PathsParameter; +class NumberParameter extends Parameter { + constructor() { + super(...arguments); + this.type = "number"; + } + validate(input) { + try { + return parseInt(input, 10); + } + catch (_a) { + throw new ValidationError(`Could not parse "${input}" as number`); + } + } +} +exports.NumberParameter = NumberParameter; +class ChoicesParameter extends Parameter { + constructor(args) { + super(args); + this.type = "choice"; + this.choices = args.choices; + } + validate(input) { + if (this.choices.includes(input)) { + return input; + } + else { + throw new ValidationError(`"${input}" is not a valid argument`); + } + } + autoComplete() { + return __awaiter(this, void 0, void 0, function* () { + return this.choices; + }); + } +} +exports.ChoicesParameter = ChoicesParameter; +class BooleanParameter extends Parameter { + constructor() { + super(...arguments); + this.type = "boolean"; + } + validate(input) { + return !!input; + } +} +exports.BooleanParameter = BooleanParameter; +// TODO: maybe this should be a global option? +class EnvironmentOption extends StringParameter { + constructor({ help = "The environment (and optionally namespace) to work against" } = {}) { + super({ + help, + required: false, + alias: "e", + }); + } +} +exports.EnvironmentOption = EnvironmentOption; +class Command { + constructor(parent) { + this.parent = parent; + this.noProject = false; + this.subCommands = []; + } + getFullName() { + return !!this.parent ? `${this.parent.getFullName()} ${this.name}` : this.name; + } + describe() { + const { name, help, description } = this; + return { + name, + fullName: this.getFullName(), + help, + description, + arguments: describeParameters(this.arguments), + options: describeParameters(this.options), + }; + } +} +exports.Command = Command; +function handleTaskResults(garden, taskType, results) { + return __awaiter(this, void 0, void 0, function* () { + const failed = Object.values(results.taskResults).filter(r => !!r.error).length; + if (failed) { + const error = new exceptions_1.RuntimeError(`${failed} ${taskType} task(s) failed!`, { + results, + }); + return { errors: [error] }; + } + garden.log.info(""); + if (!results.restartRequired) { + garden.log.header({ emoji: "heavy_check_mark", command: `Done!` }); + } + return { + result: results.taskResults, + restartRequired: results.restartRequired, + }; + }); +} +exports.handleTaskResults = handleTaskResults; +function describeParameters(args) { + if (!args) { + return; + } + return Object.entries(args).map(([argName, arg]) => (Object.assign({ name: argName, usageName: arg.required ? `<${argName}>` : `[${argName}]` }, arg))); +} +exports.describeParameters = describeParameters; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["commands/base.ts"],"names":[],"mappings":"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","file":"commands/base.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport {\n  GardenError,\n  RuntimeError,\n} from \"../exceptions\"\nimport { TaskResults } from \"../task-graph\"\nimport { LoggerType } from \"../logger/logger\"\nimport { ProcessResults } from \"../process\"\nimport { Garden } from \"../garden\"\n\nexport class ValidationError extends Error { }\n\nexport interface ParameterConstructor<T> {\n  help: string,\n  required?: boolean,\n  alias?: string,\n  defaultValue?: T,\n  valueName?: string,\n  hints?: string,\n  overrides?: string[],\n}\n\nexport abstract class Parameter<T> {\n  abstract type: string\n\n  _valueType: T\n\n  defaultValue: T | undefined\n  help: string\n  required: boolean\n  alias?: string\n  hints?: string\n  valueName: string\n  overrides: string[]\n\n  constructor({ help, required, alias, defaultValue, valueName, overrides, hints }: ParameterConstructor<T>) {\n    this.help = help\n    this.required = required || false\n    this.alias = alias\n    this.hints = hints\n    this.defaultValue = defaultValue\n    this.valueName = valueName || \"_valueType\"\n    this.overrides = overrides || []\n  }\n\n  coerce(input: T): T | undefined {\n    return input\n  }\n\n  abstract validate(input: string): T\n\n  async autoComplete(): Promise<string[]> {\n    return []\n  }\n}\n\nexport class StringParameter extends Parameter<string> {\n  type = \"string\"\n\n  validate(input: string) {\n    return input\n  }\n}\n\n// Separating this from StringParameter for now because we can't set the output type based on the required flag\n// FIXME: Maybe use a Required<Parameter> type to enforce presence, rather that an option flag?\nexport class StringOption extends Parameter<string | undefined> {\n  type = \"string\"\n\n  validate(input?: string) {\n    return input\n  }\n}\n\nexport class StringsParameter extends Parameter<string[] | undefined> {\n  type = \"array:string\"\n\n  // Sywac returns [undefined] if input is empty so we coerce that into undefined.\n  // This only applies to optional parameters since Sywac would throw if input is empty for a required parameter.\n  coerce(input: string[]) {\n    const filtered = input.filter(i => !!i)\n    if (filtered.length < 1) {\n      return undefined\n    }\n    return filtered\n  }\n\n  validate(input: string) {\n    return input.split(\",\")\n  }\n}\n\nexport class PathParameter extends Parameter<string> {\n  type = \"path\"\n\n  validate(input: string) {\n    return input\n  }\n}\n\nexport class PathsParameter extends Parameter<string[]> {\n  type = \"array:path\"\n\n  validate(input: string) {\n    return input.split(\",\")\n  }\n}\n\nexport class NumberParameter extends Parameter<number> {\n  type = \"number\"\n\n  validate(input: string) {\n    try {\n      return parseInt(input, 10)\n    } catch {\n      throw new ValidationError(`Could not parse \"${input}\" as number`)\n    }\n  }\n}\n\nexport interface ChoicesConstructor extends ParameterConstructor<string> {\n  choices: string[],\n}\n\nexport class ChoicesParameter extends Parameter<string> {\n  type = \"choice\"\n  choices: string[]\n\n  constructor(args: ChoicesConstructor) {\n    super(args)\n\n    this.choices = args.choices\n  }\n\n  validate(input: string) {\n    if (this.choices.includes(input)) {\n      return input\n    } else {\n      throw new ValidationError(`\"${input}\" is not a valid argument`)\n    }\n  }\n\n  async autoComplete() {\n    return this.choices\n  }\n}\n\nexport class BooleanParameter extends Parameter<boolean> {\n  type = \"boolean\"\n\n  validate(input: any) {\n    return !!input\n  }\n}\n\n// TODO: maybe this should be a global option?\nexport class EnvironmentOption extends StringParameter {\n  constructor({ help = \"The environment (and optionally namespace) to work against\" } = {}) {\n    super({\n      help,\n      required: false,\n      alias: \"e\",\n    })\n  }\n}\n\nexport type Parameters = { [key: string]: Parameter<any> }\nexport type ParameterValues<T extends Parameters> = { [P in keyof T]: T[P][\"_valueType\"] }\n\nexport interface CommandConstructor {\n  new(parent?: Command): Command\n}\n\nexport interface CommandResult<T = any> {\n  result?: T\n  restartRequired?: boolean\n  errors?: GardenError[]\n}\n\nexport interface CommandParams<T extends Parameters = {}, U extends Parameters = {}> {\n  args: ParameterValues<T>\n  opts: ParameterValues<U>\n  garden: Garden\n}\n\nexport abstract class Command<T extends Parameters = {}, U extends Parameters = {}> {\n  abstract name: string\n  abstract help: string\n\n  description?: string\n\n  alias?: string\n  loggerType?: LoggerType\n\n  arguments?: T\n  options?: U\n\n  noProject: boolean = false\n  subCommands: CommandConstructor[] = []\n\n  constructor(private parent?: Command) { }\n\n  getFullName() {\n    return !!this.parent ? `${this.parent.getFullName()} ${this.name}` : this.name\n  }\n\n  describe() {\n    const { name, help, description } = this\n\n    return {\n      name,\n      fullName: this.getFullName(),\n      help,\n      description,\n      arguments: describeParameters(this.arguments),\n      options: describeParameters(this.options),\n    }\n  }\n\n  // Note: Due to a current TS limitation (apparently covered by https://github.com/Microsoft/TypeScript/issues/7011),\n  // subclass implementations need to explicitly set the types in the implemented function signature. So for now we\n  // can't enforce the types of `args` and `opts` automatically at the abstract class level and have to specify\n  // the types explicitly on the subclassed methods.\n  abstract async action(params: CommandParams<T, U>): Promise<CommandResult>\n}\n\nexport async function handleTaskResults(\n  garden: Garden, taskType: string, results: ProcessResults,\n): Promise<CommandResult<TaskResults>> {\n  const failed = Object.values(results.taskResults).filter(r => !!r.error).length\n\n  if (failed) {\n    const error = new RuntimeError(`${failed} ${taskType} task(s) failed!`, {\n      results,\n    })\n    return { errors: [error] }\n  }\n\n  garden.log.info(\"\")\n  if (!results.restartRequired) {\n    garden.log.header({ emoji: \"heavy_check_mark\", command: `Done!` })\n  }\n  return {\n    result: results.taskResults,\n    restartRequired: results.restartRequired,\n  }\n}\n\nexport function describeParameters(args?: Parameters) {\n  if (!args) { return }\n  return Object.entries(args).map(([argName, arg]) => ({\n    name: argName,\n    usageName: arg.required ? `<${argName}>` : `[${argName}]`,\n    ...arg,\n  }))\n}\n"]} diff --git a/garden-service/build/commands/build.d.ts b/garden-service/build/commands/build.d.ts new file mode 100644 index 00000000000..812edf1cb5a --- /dev/null +++ b/garden-service/build/commands/build.d.ts @@ -0,0 +1,26 @@ +import { BooleanParameter, Command, CommandResult, CommandParams, StringsParameter } from "./base"; +import { TaskResults } from "../task-graph"; +declare const buildArguments: { + module: StringsParameter; +}; +declare const buildOptions: { + force: BooleanParameter; + watch: BooleanParameter; +}; +declare type BuildArguments = typeof buildArguments; +declare type BuildOptions = typeof buildOptions; +export declare class BuildCommand extends Command { + name: string; + help: string; + description: string; + arguments: { + module: StringsParameter; + }; + options: { + force: BooleanParameter; + watch: BooleanParameter; + }; + action({ args, opts, garden }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=build.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/build.js b/garden-service/build/commands/build.js new file mode 100644 index 00000000000..f541c92c617 --- /dev/null +++ b/garden-service/build/commands/build.js @@ -0,0 +1,75 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("./base"); +const build_1 = require("../tasks/build"); +const dedent = require("dedent"); +const process_1 = require("../process"); +const watch_1 = require("../watch"); +const buildArguments = { + module: new base_1.StringsParameter({ + help: "Specify module(s) to build. Use comma separator to specify multiple modules.", + }), +}; +const buildOptions = { + force: new base_1.BooleanParameter({ help: "Force rebuild of module(s)." }), + watch: new base_1.BooleanParameter({ help: "Watch for changes in module(s) and auto-build.", alias: "w" }), +}; +class BuildCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "build"; + this.help = "Build your modules."; + this.description = dedent ` + Builds all or specified modules, taking into account build dependency order. + Optionally stays running and automatically builds modules if their source (or their dependencies' sources) change. + + Examples: + + garden build # build all modules in the project + garden build my-module # only build my-module + garden build --force # force rebuild of modules + garden build --watch # watch for changes to code + `; + this.arguments = buildArguments; + this.options = buildOptions; + } + action({ args, opts, garden }) { + return __awaiter(this, void 0, void 0, function* () { + yield garden.clearBuilds(); + const autoReloadDependants = yield watch_1.computeAutoReloadDependants(garden); + const modules = yield garden.getModules(args.module); + const moduleNames = modules.map(m => m.name); + garden.log.header({ emoji: "hammer", command: "Build" }); + const results = yield process_1.processModules({ + garden, + modules, + watch: opts.watch, + handler: (module) => __awaiter(this, void 0, void 0, function* () { return [new build_1.BuildTask({ garden, module, force: opts.force })]; }), + changeHandler: (module) => __awaiter(this, void 0, void 0, function* () { + return (yield watch_1.withDependants(garden, [module], autoReloadDependants)) + .filter(m => moduleNames.includes(m.name)) + .map(m => new build_1.BuildTask({ garden, module: m, force: true })); + }), + }); + return base_1.handleTaskResults(garden, "build", results); + }); + } +} +exports.BuildCommand = BuildCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbW1hbmRzL2J1aWxkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7QUFFSCxpQ0FPZTtBQUNmLDBDQUEwQztBQUUxQyxpQ0FBaUM7QUFDakMsd0NBQTJDO0FBQzNDLG9DQUFzRTtBQUd0RSxNQUFNLGNBQWMsR0FBRztJQUNyQixNQUFNLEVBQUUsSUFBSSx1QkFBZ0IsQ0FBQztRQUMzQixJQUFJLEVBQUUsOEVBQThFO0tBQ3JGLENBQUM7Q0FDSCxDQUFBO0FBRUQsTUFBTSxZQUFZLEdBQUc7SUFDbkIsS0FBSyxFQUFFLElBQUksdUJBQWdCLENBQUMsRUFBRSxJQUFJLEVBQUUsNkJBQTZCLEVBQUUsQ0FBQztJQUNwRSxLQUFLLEVBQUUsSUFBSSx1QkFBZ0IsQ0FBQyxFQUFFLElBQUksRUFBRSxnREFBZ0QsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLENBQUM7Q0FDcEcsQ0FBQTtBQUtELE1BQWEsWUFBYSxTQUFRLGNBQXFDO0lBQXZFOztRQUNFLFNBQUksR0FBRyxPQUFPLENBQUE7UUFDZCxTQUFJLEdBQUcscUJBQXFCLENBQUE7UUFFNUIsZ0JBQVcsR0FBRyxNQUFNLENBQUE7Ozs7Ozs7Ozs7R0FVbkIsQ0FBQTtRQUVELGNBQVMsR0FBRyxjQUFjLENBQUE7UUFDMUIsWUFBTyxHQUFHLFlBQVksQ0FBQTtJQTRCeEIsQ0FBQztJQTFCTyxNQUFNLENBQ1YsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBK0M7O1lBR25FLE1BQU0sTUFBTSxDQUFDLFdBQVcsRUFBRSxDQUFBO1lBRTFCLE1BQU0sb0JBQW9CLEdBQUcsTUFBTSxtQ0FBMkIsQ0FBQyxNQUFNLENBQUMsQ0FBQTtZQUN0RSxNQUFNLE9BQU8sR0FBRyxNQUFNLE1BQU0sQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFBO1lBQ3BELE1BQU0sV0FBVyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUE7WUFFNUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFBO1lBRXhELE1BQU0sT0FBTyxHQUFHLE1BQU0sd0JBQWMsQ0FBQztnQkFDbkMsTUFBTTtnQkFDTixPQUFPO2dCQUNQLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSztnQkFDakIsT0FBTyxFQUFFLENBQU8sTUFBTSxFQUFFLEVBQUUsZ0RBQUMsT0FBQSxDQUFDLElBQUksaUJBQVMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUEsR0FBQTtnQkFDakYsYUFBYSxFQUFFLENBQU8sTUFBYyxFQUFFLEVBQUU7b0JBQ3RDLE9BQU8sQ0FBQyxNQUFNLHNCQUFjLENBQUMsTUFBTSxFQUFFLENBQUMsTUFBTSxDQUFDLEVBQUUsb0JBQW9CLENBQUMsQ0FBQzt5QkFDbEUsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUM7eUJBQ3pDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLElBQUksaUJBQVMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUE7Z0JBQ2hFLENBQUMsQ0FBQTthQUNGLENBQUMsQ0FBQTtZQUVGLE9BQU8sd0JBQWlCLENBQUMsTUFBTSxFQUFFLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQTtRQUNwRCxDQUFDO0tBQUE7Q0FDRjtBQTdDRCxvQ0E2Q0MiLCJmaWxlIjoiY29tbWFuZHMvYnVpbGQuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChDKSAyMDE4IEdhcmRlbiBUZWNobm9sb2dpZXMsIEluYy4gPGluZm9AZ2FyZGVuLmlvPlxuICpcbiAqIFRoaXMgU291cmNlIENvZGUgRm9ybSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGUgTW96aWxsYSBQdWJsaWNcbiAqIExpY2Vuc2UsIHYuIDIuMC4gSWYgYSBjb3B5IG9mIHRoZSBNUEwgd2FzIG5vdCBkaXN0cmlidXRlZCB3aXRoIHRoaXNcbiAqIGZpbGUsIFlvdSBjYW4gb2J0YWluIG9uZSBhdCBodHRwOi8vbW96aWxsYS5vcmcvTVBMLzIuMC8uXG4gKi9cblxuaW1wb3J0IHtcbiAgQm9vbGVhblBhcmFtZXRlcixcbiAgQ29tbWFuZCxcbiAgQ29tbWFuZFJlc3VsdCxcbiAgQ29tbWFuZFBhcmFtcyxcbiAgaGFuZGxlVGFza1Jlc3VsdHMsXG4gIFN0cmluZ3NQYXJhbWV0ZXIsXG59IGZyb20gXCIuL2Jhc2VcIlxuaW1wb3J0IHsgQnVpbGRUYXNrIH0gZnJvbSBcIi4uL3Rhc2tzL2J1aWxkXCJcbmltcG9ydCB7IFRhc2tSZXN1bHRzIH0gZnJvbSBcIi4uL3Rhc2stZ3JhcGhcIlxuaW1wb3J0IGRlZGVudCA9IHJlcXVpcmUoXCJkZWRlbnRcIilcbmltcG9ydCB7IHByb2Nlc3NNb2R1bGVzIH0gZnJvbSBcIi4uL3Byb2Nlc3NcIlxuaW1wb3J0IHsgY29tcHV0ZUF1dG9SZWxvYWREZXBlbmRhbnRzLCB3aXRoRGVwZW5kYW50cyB9IGZyb20gXCIuLi93YXRjaFwiXG5pbXBvcnQgeyBNb2R1bGUgfSBmcm9tIFwiLi4vdHlwZXMvbW9kdWxlXCJcblxuY29uc3QgYnVpbGRBcmd1bWVudHMgPSB7XG4gIG1vZHVsZTogbmV3IFN0cmluZ3NQYXJhbWV0ZXIoe1xuICAgIGhlbHA6IFwiU3BlY2lmeSBtb2R1bGUocykgdG8gYnVpbGQuIFVzZSBjb21tYSBzZXBhcmF0b3IgdG8gc3BlY2lmeSBtdWx0aXBsZSBtb2R1bGVzLlwiLFxuICB9KSxcbn1cblxuY29uc3QgYnVpbGRPcHRpb25zID0ge1xuICBmb3JjZTogbmV3IEJvb2xlYW5QYXJhbWV0ZXIoeyBoZWxwOiBcIkZvcmNlIHJlYnVpbGQgb2YgbW9kdWxlKHMpLlwiIH0pLFxuICB3YXRjaDogbmV3IEJvb2xlYW5QYXJhbWV0ZXIoeyBoZWxwOiBcIldhdGNoIGZvciBjaGFuZ2VzIGluIG1vZHVsZShzKSBhbmQgYXV0by1idWlsZC5cIiwgYWxpYXM6IFwid1wiIH0pLFxufVxuXG50eXBlIEJ1aWxkQXJndW1lbnRzID0gdHlwZW9mIGJ1aWxkQXJndW1lbnRzXG50eXBlIEJ1aWxkT3B0aW9ucyA9IHR5cGVvZiBidWlsZE9wdGlvbnNcblxuZXhwb3J0IGNsYXNzIEJ1aWxkQ29tbWFuZCBleHRlbmRzIENvbW1hbmQ8QnVpbGRBcmd1bWVudHMsIEJ1aWxkT3B0aW9ucz4ge1xuICBuYW1lID0gXCJidWlsZFwiXG4gIGhlbHAgPSBcIkJ1aWxkIHlvdXIgbW9kdWxlcy5cIlxuXG4gIGRlc2NyaXB0aW9uID0gZGVkZW50YFxuICAgIEJ1aWxkcyBhbGwgb3Igc3BlY2lmaWVkIG1vZHVsZXMsIHRha2luZyBpbnRvIGFjY291bnQgYnVpbGQgZGVwZW5kZW5jeSBvcmRlci5cbiAgICBPcHRpb25hbGx5IHN0YXlzIHJ1bm5pbmcgYW5kIGF1dG9tYXRpY2FsbHkgYnVpbGRzIG1vZHVsZXMgaWYgdGhlaXIgc291cmNlIChvciB0aGVpciBkZXBlbmRlbmNpZXMnIHNvdXJjZXMpIGNoYW5nZS5cblxuICAgIEV4YW1wbGVzOlxuXG4gICAgICAgIGdhcmRlbiBidWlsZCAgICAgICAgICAgICMgYnVpbGQgYWxsIG1vZHVsZXMgaW4gdGhlIHByb2plY3RcbiAgICAgICAgZ2FyZGVuIGJ1aWxkIG15LW1vZHVsZSAgIyBvbmx5IGJ1aWxkIG15LW1vZHVsZVxuICAgICAgICBnYXJkZW4gYnVpbGQgLS1mb3JjZSAgICAjIGZvcmNlIHJlYnVpbGQgb2YgbW9kdWxlc1xuICAgICAgICBnYXJkZW4gYnVpbGQgLS13YXRjaCAgICAjIHdhdGNoIGZvciBjaGFuZ2VzIHRvIGNvZGVcbiAgYFxuXG4gIGFyZ3VtZW50cyA9IGJ1aWxkQXJndW1lbnRzXG4gIG9wdGlvbnMgPSBidWlsZE9wdGlvbnNcblxuICBhc3luYyBhY3Rpb24oXG4gICAgeyBhcmdzLCBvcHRzLCBnYXJkZW4gfTogQ29tbWFuZFBhcmFtczxCdWlsZEFyZ3VtZW50cywgQnVpbGRPcHRpb25zPixcbiAgKTogUHJvbWlzZTxDb21tYW5kUmVzdWx0PFRhc2tSZXN1bHRzPj4ge1xuXG4gICAgYXdhaXQgZ2FyZGVuLmNsZWFyQnVpbGRzKClcblxuICAgIGNvbnN0IGF1dG9SZWxvYWREZXBlbmRhbnRzID0gYXdhaXQgY29tcHV0ZUF1dG9SZWxvYWREZXBlbmRhbnRzKGdhcmRlbilcbiAgICBjb25zdCBtb2R1bGVzID0gYXdhaXQgZ2FyZGVuLmdldE1vZHVsZXMoYXJncy5tb2R1bGUpXG4gICAgY29uc3QgbW9kdWxlTmFtZXMgPSBtb2R1bGVzLm1hcChtID0+IG0ubmFtZSlcblxuICAgIGdhcmRlbi5sb2cuaGVhZGVyKHsgZW1vamk6IFwiaGFtbWVyXCIsIGNvbW1hbmQ6IFwiQnVpbGRcIiB9KVxuXG4gICAgY29uc3QgcmVzdWx0cyA9IGF3YWl0IHByb2Nlc3NNb2R1bGVzKHtcbiAgICAgIGdhcmRlbixcbiAgICAgIG1vZHVsZXMsXG4gICAgICB3YXRjaDogb3B0cy53YXRjaCxcbiAgICAgIGhhbmRsZXI6IGFzeW5jIChtb2R1bGUpID0+IFtuZXcgQnVpbGRUYXNrKHsgZ2FyZGVuLCBtb2R1bGUsIGZvcmNlOiBvcHRzLmZvcmNlIH0pXSxcbiAgICAgIGNoYW5nZUhhbmRsZXI6IGFzeW5jIChtb2R1bGU6IE1vZHVsZSkgPT4ge1xuICAgICAgICByZXR1cm4gKGF3YWl0IHdpdGhEZXBlbmRhbnRzKGdhcmRlbiwgW21vZHVsZV0sIGF1dG9SZWxvYWREZXBlbmRhbnRzKSlcbiAgICAgICAgICAuZmlsdGVyKG0gPT4gbW9kdWxlTmFtZXMuaW5jbHVkZXMobS5uYW1lKSlcbiAgICAgICAgICAubWFwKG0gPT4gbmV3IEJ1aWxkVGFzayh7IGdhcmRlbiwgbW9kdWxlOiBtLCBmb3JjZTogdHJ1ZSB9KSlcbiAgICAgIH0sXG4gICAgfSlcblxuICAgIHJldHVybiBoYW5kbGVUYXNrUmVzdWx0cyhnYXJkZW4sIFwiYnVpbGRcIiwgcmVzdWx0cylcbiAgfVxufVxuIl19 diff --git a/garden-service/build/commands/call.d.ts b/garden-service/build/commands/call.d.ts new file mode 100644 index 00000000000..9f8af097c49 --- /dev/null +++ b/garden-service/build/commands/call.d.ts @@ -0,0 +1,16 @@ +import { Command, CommandResult, CommandParams, StringParameter } from "./base"; +declare const callArgs: { + serviceAndPath: StringParameter; +}; +declare type Args = typeof callArgs; +export declare class CallCommand extends Command { + name: string; + help: string; + description: string; + arguments: { + serviceAndPath: StringParameter; + }; + action({ garden, args }: CommandParams): Promise; +} +export {}; +//# sourceMappingURL=call.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/call.js b/garden-service/build/commands/call.js new file mode 100644 index 00000000000..dda9ed23f70 --- /dev/null +++ b/garden-service/build/commands/call.js @@ -0,0 +1,155 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const url_1 = require("url"); +const axios_1 = require("axios"); +const chalk_1 = require("chalk"); +const util_1 = require("util"); +const base_1 = require("./base"); +const util_2 = require("../util/util"); +const exceptions_1 = require("../exceptions"); +const lodash_1 = require("lodash"); +const service_1 = require("../types/service"); +const dedent = require("dedent"); +const callArgs = { + serviceAndPath: new base_1.StringParameter({ + help: "The name of the service(s) to call followed by the ingress path (e.g. my-container/somepath).", + required: true, + }), +}; +class CallCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "call"; + this.help = "Call a service ingress endpoint."; + this.description = dedent ` + This command resolves the deployed ingress endpoint for the given service and path, calls the given endpoint and + outputs the result. + + Examples: + + garden call my-container + garden call my-container/some-path + + Note: Currently only supports simple GET requests for HTTP/HTTPS ingresses. + `; + this.arguments = callArgs; + } + action({ garden, args }) { + return __awaiter(this, void 0, void 0, function* () { + let [serviceName, path] = util_2.splitFirst(args.serviceAndPath, "/"); + // TODO: better error when service doesn't exist + const service = yield garden.getService(serviceName); + const status = yield garden.actions.getServiceStatus({ service }); + if (status.state !== "ready") { + throw new exceptions_1.RuntimeError(`Service ${service.name} is not running`, { + serviceName: service.name, + status, + }); + } + if (!status.ingresses) { + throw new exceptions_1.ParameterError(`Service ${service.name} has no active ingresses`, { + serviceName: service.name, + serviceStatus: status, + }); + } + // find the correct endpoint to call + let matchedIngress = null; + let matchedPath; + // we can't easily support raw TCP or UDP in a command like this + const ingresses = status.ingresses.filter(e => e.protocol === "http" || e.protocol === "https"); + if (!path) { + // if no path is specified and there's a root endpoint (path === "/") we use that + const rootIngress = lodash_1.find(ingresses, e => e.path === "/"); + if (rootIngress) { + matchedIngress = rootIngress; + matchedPath = "/"; + } + else { + // if there's no root endpoint, pick the first endpoint + matchedIngress = ingresses[0]; + matchedPath = ingresses[0].path; + } + path = matchedPath; + } + else { + path = "/" + path; + for (const ingress of status.ingresses) { + if (ingress.path) { + if (path.startsWith(ingress.path) && (!matchedPath || ingress.path.length > matchedPath.length)) { + matchedIngress = ingress; + matchedPath = ingress.path; + } + } + else if (!matchedPath) { + matchedIngress = ingress; + } + } + } + if (!matchedIngress) { + throw new exceptions_1.ParameterError(`Service ${service.name} does not have an HTTP/HTTPS ingress at ${path}`, { + serviceName: service.name, + path, + availableIngresses: status.ingresses, + }); + } + const url = url_1.resolve(service_1.getIngressUrl(matchedIngress), path || matchedPath); + // TODO: support POST requests with request body + const method = "get"; + const entry = garden.log.info({ + msg: chalk_1.default.cyan(`Sending ${matchedIngress.protocol.toUpperCase()} GET request to `) + url + "\n", + status: "active", + }); + // this is to accept self-signed certs + process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0"; + const req = axios_1.default({ + method, + url, + headers: { + host: matchedIngress.hostname, + }, + }); + // TODO: add verbose and debug logging (request/response headers etc.) + let res; + try { + res = yield req; + entry.setSuccess(); + garden.log.info(chalk_1.default.green(`${res.status} ${res.statusText}\n`)); + } + catch (err) { + res = err.response; + entry.setError(); + const error = res ? `${res.status} ${res.statusText}` : err.message; + garden.log.info(chalk_1.default.red(error + "\n")); + return {}; + } + const resStr = util_1.isObject(res.data) ? JSON.stringify(res.data, null, 2) : res.data; + res.data && garden.log.info(chalk_1.default.white(resStr) + "\n"); + return { + result: { + serviceName, + path, + url, + response: lodash_1.pick(res, ["status", "statusText", "headers", "data"]), + }, + }; + }); + } +} +exports.CallCommand = CallCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["commands/call.ts"],"names":[],"mappings":"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","file":"commands/call.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { resolve } from \"url\"\nimport Axios from \"axios\"\nimport chalk from \"chalk\"\nimport { isObject } from \"util\"\nimport {\n  Command,\n  CommandResult,\n  CommandParams,\n  StringParameter,\n} from \"./base\"\nimport { splitFirst } from \"../util/util\"\nimport { ParameterError, RuntimeError } from \"../exceptions\"\nimport { pick, find } from \"lodash\"\nimport { ServiceIngress, getIngressUrl } from \"../types/service\"\nimport dedent = require(\"dedent\")\n\nconst callArgs = {\n  serviceAndPath: new StringParameter({\n    help: \"The name of the service(s) to call followed by the ingress path (e.g. my-container/somepath).\",\n    required: true,\n  }),\n}\n\ntype Args = typeof callArgs\n\nexport class CallCommand extends Command<Args> {\n  name = \"call\"\n  help = \"Call a service ingress endpoint.\"\n\n  description = dedent`\n    This command resolves the deployed ingress endpoint for the given service and path, calls the given endpoint and\n    outputs the result.\n\n    Examples:\n\n        garden call my-container\n        garden call my-container/some-path\n\n    Note: Currently only supports simple GET requests for HTTP/HTTPS ingresses.\n  `\n\n  arguments = callArgs\n\n  async action({ garden, args }: CommandParams<Args>): Promise<CommandResult> {\n    let [serviceName, path] = splitFirst(args.serviceAndPath, \"/\")\n\n    // TODO: better error when service doesn't exist\n    const service = await garden.getService(serviceName)\n    const status = await garden.actions.getServiceStatus({ service })\n\n    if (status.state !== \"ready\") {\n      throw new RuntimeError(`Service ${service.name} is not running`, {\n        serviceName: service.name,\n        status,\n      })\n    }\n\n    if (!status.ingresses) {\n      throw new ParameterError(`Service ${service.name} has no active ingresses`, {\n        serviceName: service.name,\n        serviceStatus: status,\n      })\n    }\n\n    // find the correct endpoint to call\n    let matchedIngress: ServiceIngress | null = null\n    let matchedPath\n\n    // we can't easily support raw TCP or UDP in a command like this\n    const ingresses = status.ingresses.filter(e => e.protocol === \"http\" || e.protocol === \"https\")\n\n    if (!path) {\n      // if no path is specified and there's a root endpoint (path === \"/\") we use that\n      const rootIngress = <ServiceIngress>find(ingresses, e => e.path === \"/\")\n\n      if (rootIngress) {\n        matchedIngress = rootIngress\n        matchedPath = \"/\"\n      } else {\n        // if there's no root endpoint, pick the first endpoint\n        matchedIngress = ingresses[0]\n        matchedPath = ingresses[0].path\n      }\n\n      path = matchedPath\n\n    } else {\n      path = \"/\" + path\n\n      for (const ingress of status.ingresses) {\n        if (ingress.path) {\n          if (path.startsWith(ingress.path) && (!matchedPath || ingress.path.length > matchedPath.length)) {\n            matchedIngress = ingress\n            matchedPath = ingress.path\n          }\n        } else if (!matchedPath) {\n          matchedIngress = ingress\n        }\n      }\n    }\n\n    if (!matchedIngress) {\n      throw new ParameterError(`Service ${service.name} does not have an HTTP/HTTPS ingress at ${path}`, {\n        serviceName: service.name,\n        path,\n        availableIngresses: status.ingresses,\n      })\n    }\n\n    const url = resolve(getIngressUrl(matchedIngress), path || matchedPath)\n    // TODO: support POST requests with request body\n    const method = \"get\"\n\n    const entry = garden.log.info({\n      msg: chalk.cyan(`Sending ${matchedIngress.protocol.toUpperCase()} GET request to `) + url + \"\\n\",\n      status: \"active\",\n    })\n\n    // this is to accept self-signed certs\n    process.env.NODE_TLS_REJECT_UNAUTHORIZED = \"0\"\n\n    const req = Axios({\n      method,\n      url,\n      headers: {\n        host: matchedIngress.hostname,\n      },\n    })\n\n    // TODO: add verbose and debug logging (request/response headers etc.)\n    let res\n\n    try {\n      res = await req\n      entry.setSuccess()\n      garden.log.info(chalk.green(`${res.status} ${res.statusText}\\n`))\n    } catch (err) {\n      res = err.response\n      entry.setError()\n      const error = res ? `${res.status} ${res.statusText}` : err.message\n      garden.log.info(chalk.red(error + \"\\n\"))\n      return {}\n    }\n\n    const resStr = isObject(res.data) ? JSON.stringify(res.data, null, 2) : res.data\n\n    res.data && garden.log.info(chalk.white(resStr) + \"\\n\")\n\n    return {\n      result: {\n        serviceName,\n        path,\n        url,\n        response: pick(res, [\"status\", \"statusText\", \"headers\", \"data\"]),\n      },\n    }\n  }\n}\n"]} diff --git a/garden-service/build/commands/commands.d.ts b/garden-service/build/commands/commands.d.ts new file mode 100644 index 00000000000..2af1247a565 --- /dev/null +++ b/garden-service/build/commands/commands.d.ts @@ -0,0 +1,3 @@ +import { Command } from "./base"; +export declare const coreCommands: Command[]; +//# sourceMappingURL=commands.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/commands.js b/garden-service/build/commands/commands.js new file mode 100644 index 00000000000..7f2af8082ab --- /dev/null +++ b/garden-service/build/commands/commands.js @@ -0,0 +1,51 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const build_1 = require("./build"); +const create_1 = require("./create/create"); +const call_1 = require("./call"); +const init_1 = require("./init"); +const delete_1 = require("./delete"); +const deploy_1 = require("./deploy"); +const dev_1 = require("./dev"); +const get_1 = require("./get"); +const link_1 = require("./link/link"); +const logs_1 = require("./logs"); +const publish_1 = require("./publish"); +const run_1 = require("./run/run"); +const scan_1 = require("./scan"); +const set_1 = require("./set"); +const test_1 = require("./test"); +const unlink_1 = require("./unlink/unlink"); +const update_remote_1 = require("./update-remote/update-remote"); +const validate_1 = require("./validate"); +const exec_1 = require("./exec"); +exports.coreCommands = [ + new build_1.BuildCommand(), + new call_1.CallCommand(), + new create_1.CreateCommand(), + new delete_1.DeleteCommand(), + new deploy_1.DeployCommand(), + new dev_1.DevCommand(), + new exec_1.ExecCommand(), + new get_1.GetCommand(), + new init_1.InitCommand(), + new link_1.LinkCommand(), + new logs_1.LogsCommand(), + new publish_1.PublishCommand(), + new run_1.RunCommand(), + new scan_1.ScanCommand(), + new set_1.SetCommand(), + new test_1.TestCommand(), + new unlink_1.UnlinkCommand(), + new update_remote_1.UpdateRemoteCommand(), + new validate_1.ValidateCommand(), +]; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/create/config-templates.d.ts b/garden-service/build/commands/create/config-templates.d.ts new file mode 100644 index 00000000000..c402cce39df --- /dev/null +++ b/garden-service/build/commands/create/config-templates.d.ts @@ -0,0 +1,43 @@ +import * as Joi from "joi"; +import { DeepPartial } from "../../util/util"; +import { ContainerModuleSpec } from "../../plugins/container"; +import { GcfModuleSpec } from "../../plugins/google/google-cloud-functions"; +import { ProjectConfig } from "../../config/project"; +import { BaseModuleSpec, ModuleConfig } from "../../config/module"; +/** + * Ideally there would be some mechanism to discover available module types, + * and for plugins to expose a minimal config for the given type along with + * a list of providers per environment, rather than hard coding these values. + * + * Alternatively, consider co-locating the templates with the plugins. + */ +export declare const MODULE_PROVIDER_MAP: { + container: string; + "google-cloud-function": string; + "npm-package": string; +}; +export declare const availableModuleTypes: ("container" | "npm-package" | "google-cloud-function")[]; +export declare type ModuleType = keyof typeof MODULE_PROVIDER_MAP; +export declare const moduleSchema: Joi.ObjectSchema; +export interface ConfigOpts { + name: string; + path: string; + config: { + module: Partial; + } | Partial; +} +export interface ModuleConfigOpts extends ConfigOpts { + type: ModuleType; + config: { + module: Partial; + }; +} +export interface ProjectConfigOpts extends ConfigOpts { + config: Partial; +} +export declare function containerTemplate(moduleName: string): DeepPartial; +export declare function googleCloudFunctionTemplate(moduleName: string): DeepPartial; +export declare function npmPackageTemplate(_moduleName: string): any; +export declare const projectTemplate: (name: string, moduleTypes: ("container" | "npm-package" | "google-cloud-function")[]) => Partial; +export declare const moduleTemplate: (name: string, type: "container" | "npm-package" | "google-cloud-function") => Partial; +//# sourceMappingURL=config-templates.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/create/config-templates.js b/garden-service/build/commands/create/config-templates.js new file mode 100644 index 00000000000..50dc11bd291 --- /dev/null +++ b/garden-service/build/commands/create/config-templates.js @@ -0,0 +1,81 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const Joi = require("joi"); +const module_1 = require("../../config/module"); +/** + * Ideally there would be some mechanism to discover available module types, + * and for plugins to expose a minimal config for the given type along with + * a list of providers per environment, rather than hard coding these values. + * + * Alternatively, consider co-locating the templates with the plugins. + */ +exports.MODULE_PROVIDER_MAP = { + container: "local-kubernetes", + "google-cloud-function": "local-google-cloud-functions", + "npm-package": "npm-package", +}; +exports.availableModuleTypes = Object.keys(exports.MODULE_PROVIDER_MAP); +exports.moduleSchema = Joi.object().keys({ + module: module_1.baseModuleSpecSchema, +}); +const noCase = (str) => str.replace(/-|_/g, " "); +const titleize = (str) => lodash_1.capitalize(noCase(str)); +function containerTemplate(moduleName) { + return { + services: [ + { + name: `${moduleName}-service`, + ports: [{ + name: "http", + containerPort: 8080, + }], + ingresses: [{ + path: "/", + port: "http", + }], + }, + ], + }; +} +exports.containerTemplate = containerTemplate; +function googleCloudFunctionTemplate(moduleName) { + return { + functions: [{ + name: `${moduleName}-google-cloud-function`, + entrypoint: lodash_1.camelCase(`${moduleName}-google-cloud-function`), + }], + }; +} +exports.googleCloudFunctionTemplate = googleCloudFunctionTemplate; +function npmPackageTemplate(_moduleName) { + return {}; +} +exports.npmPackageTemplate = npmPackageTemplate; +exports.projectTemplate = (name, moduleTypes) => { + const providers = lodash_1.uniq(moduleTypes).map(type => ({ name: exports.MODULE_PROVIDER_MAP[type] })); + return { + name, + environments: [ + { + name: "local", + providers, + variables: {}, + }, + ], + }; +}; +exports.moduleTemplate = (name, type) => ({ + name, + type, + description: `${titleize(name)} ${noCase(type)}`, +}); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/create/create.d.ts b/garden-service/build/commands/create/create.d.ts new file mode 100644 index 00000000000..3664a416f24 --- /dev/null +++ b/garden-service/build/commands/create/create.d.ts @@ -0,0 +1,11 @@ +import { Command } from "../base"; +import { CreateProjectCommand } from "./project"; +import { CreateModuleCommand } from "./module"; +export declare class CreateCommand extends Command { + name: string; + alias: string; + help: string; + subCommands: (typeof CreateProjectCommand | typeof CreateModuleCommand)[]; + action(): Promise<{}>; +} +//# sourceMappingURL=create.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/create/create.js b/garden-service/build/commands/create/create.js new file mode 100644 index 00000000000..a34f8f9461b --- /dev/null +++ b/garden-service/build/commands/create/create.js @@ -0,0 +1,38 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("../base"); +const project_1 = require("./project"); +const module_1 = require("./module"); +class CreateCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "create"; + this.alias = "r"; + this.help = "Create a new project or add a new module"; + this.subCommands = [ + project_1.CreateProjectCommand, + module_1.CreateModuleCommand, + ]; + } + action() { + return __awaiter(this, void 0, void 0, function* () { return {}; }); + } +} +exports.CreateCommand = CreateCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbW1hbmRzL2NyZWF0ZS9jcmVhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7OztBQUVILGtDQUFpQztBQUNqQyx1Q0FBZ0Q7QUFDaEQscUNBQThDO0FBRTlDLE1BQWEsYUFBYyxTQUFRLGNBQU87SUFBMUM7O1FBQ0UsU0FBSSxHQUFHLFFBQVEsQ0FBQTtRQUNmLFVBQUssR0FBRyxHQUFHLENBQUE7UUFDWCxTQUFJLEdBQUcsMENBQTBDLENBQUE7UUFFakQsZ0JBQVcsR0FBRztZQUNaLDhCQUFvQjtZQUNwQiw0QkFBbUI7U0FDcEIsQ0FBQTtJQUdILENBQUM7SUFETyxNQUFNOzhEQUFLLE9BQU8sRUFBRSxDQUFBLENBQUMsQ0FBQztLQUFBO0NBQzdCO0FBWEQsc0NBV0MiLCJmaWxlIjoiY29tbWFuZHMvY3JlYXRlL2NyZWF0ZS5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKEMpIDIwMTggR2FyZGVuIFRlY2hub2xvZ2llcywgSW5jLiA8aW5mb0BnYXJkZW4uaW8+XG4gKlxuICogVGhpcyBTb3VyY2UgQ29kZSBGb3JtIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoZSBNb3ppbGxhIFB1YmxpY1xuICogTGljZW5zZSwgdi4gMi4wLiBJZiBhIGNvcHkgb2YgdGhlIE1QTCB3YXMgbm90IGRpc3RyaWJ1dGVkIHdpdGggdGhpc1xuICogZmlsZSwgWW91IGNhbiBvYnRhaW4gb25lIGF0IGh0dHA6Ly9tb3ppbGxhLm9yZy9NUEwvMi4wLy5cbiAqL1xuXG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcIi4uL2Jhc2VcIlxuaW1wb3J0IHsgQ3JlYXRlUHJvamVjdENvbW1hbmQgfSBmcm9tIFwiLi9wcm9qZWN0XCJcbmltcG9ydCB7IENyZWF0ZU1vZHVsZUNvbW1hbmQgfSBmcm9tIFwiLi9tb2R1bGVcIlxuXG5leHBvcnQgY2xhc3MgQ3JlYXRlQ29tbWFuZCBleHRlbmRzIENvbW1hbmQge1xuICBuYW1lID0gXCJjcmVhdGVcIlxuICBhbGlhcyA9IFwiclwiXG4gIGhlbHAgPSBcIkNyZWF0ZSBhIG5ldyBwcm9qZWN0IG9yIGFkZCBhIG5ldyBtb2R1bGVcIlxuXG4gIHN1YkNvbW1hbmRzID0gW1xuICAgIENyZWF0ZVByb2plY3RDb21tYW5kLFxuICAgIENyZWF0ZU1vZHVsZUNvbW1hbmQsXG4gIF1cblxuICBhc3luYyBhY3Rpb24oKSB7IHJldHVybiB7fSB9XG59XG4iXX0= diff --git a/garden-service/build/commands/create/helpers.d.ts b/garden-service/build/commands/create/helpers.d.ts new file mode 100644 index 00000000000..e1a40b51d20 --- /dev/null +++ b/garden-service/build/commands/create/helpers.d.ts @@ -0,0 +1,6 @@ +import * as Joi from "joi"; +import { ModuleConfigOpts, ModuleType, ConfigOpts } from "./config-templates"; +import { LogNode } from "../../logger/log-node"; +export declare function prepareNewModuleConfig(name: string, type: ModuleType, path: string): ModuleConfigOpts; +export declare function dumpConfig(configOpts: ConfigOpts, schema: Joi.Schema, logger: LogNode): Promise; +//# sourceMappingURL=helpers.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/create/helpers.js b/garden-service/build/commands/create/helpers.js new file mode 100644 index 00000000000..db429dba13b --- /dev/null +++ b/garden-service/build/commands/create/helpers.js @@ -0,0 +1,65 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const config_templates_1 = require("./config-templates"); +const path_1 = require("path"); +const fs_extra_1 = require("fs-extra"); +const common_1 = require("../../config/common"); +const util_1 = require("../../util/util"); +const constants_1 = require("../../constants"); +function prepareNewModuleConfig(name, type, path) { + const moduleTypeTemplate = { + container: config_templates_1.containerTemplate, + "google-cloud-function": config_templates_1.googleCloudFunctionTemplate, + "npm-package": config_templates_1.npmPackageTemplate, + }[type]; + return { + name, + type, + path, + config: { + module: Object.assign({}, config_templates_1.moduleTemplate(name, type), moduleTypeTemplate(name)), + }, + }; +} +exports.prepareNewModuleConfig = prepareNewModuleConfig; +function dumpConfig(configOpts, schema, logger) { + return __awaiter(this, void 0, void 0, function* () { + const { config, name, path } = configOpts; + const yamlPath = path_1.join(path, constants_1.MODULE_CONFIG_FILENAME); + const task = logger.info({ + msg: `Writing config for ${name}`, + status: "active", + }); + if (yield fs_extra_1.pathExists(yamlPath)) { + task.setWarn({ msg: `Garden config file already exists at path, skipping`, append: true }); + return; + } + try { + common_1.validate(config, schema); + yield util_1.dumpYaml(yamlPath, config); + task.setSuccess(); + } + catch (err) { + task.setError({ msg: `Generated config is invalid, skipping`, append: true }); + throw err; + } + }); +} +exports.dumpConfig = dumpConfig; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/create/module.d.ts b/garden-service/build/commands/create/module.d.ts new file mode 100644 index 00000000000..0c254266e9b --- /dev/null +++ b/garden-service/build/commands/create/module.d.ts @@ -0,0 +1,33 @@ +import { Command, CommandResult, StringParameter, ChoicesParameter, CommandParams } from "../base"; +import { ModuleConfigOpts } from "./config-templates"; +declare const createModuleOptions: { + name: StringParameter; + type: ChoicesParameter; +}; +declare const createModuleArguments: { + "module-dir": StringParameter; +}; +declare type Args = typeof createModuleArguments; +declare type Opts = typeof createModuleOptions; +interface CreateModuleResult extends CommandResult { + result: { + module?: ModuleConfigOpts; + }; +} +export declare class CreateModuleCommand extends Command { + name: string; + alias: string; + help: string; + description: string; + noProject: boolean; + arguments: { + "module-dir": StringParameter; + }; + options: { + name: StringParameter; + type: ChoicesParameter; + }; + action({ garden, args, opts }: CommandParams): Promise; +} +export {}; +//# sourceMappingURL=module.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/create/module.js b/garden-service/build/commands/create/module.js new file mode 100644 index 00000000000..7732a805cc2 --- /dev/null +++ b/garden-service/build/commands/create/module.js @@ -0,0 +1,103 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const dedent = require("dedent"); +const base_1 = require("../base"); +const exceptions_1 = require("../../exceptions"); +const config_templates_1 = require("./config-templates"); +const helpers_1 = require("./helpers"); +const prompts_1 = require("./prompts"); +const common_1 = require("../../config/common"); +const fs_extra_1 = require("fs-extra"); +const createModuleOptions = { + name: new base_1.StringParameter({ + help: "Assigns a custom name to the module. (Defaults to name of the current directory.)", + }), + type: new base_1.ChoicesParameter({ + help: "Type of module.", + choices: config_templates_1.availableModuleTypes, + }), +}; +const createModuleArguments = { + "module-dir": new base_1.StringParameter({ + help: "Directory of the module. (Defaults to current directory.)", + }), +}; +class CreateModuleCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "module"; + this.alias = "m"; + this.help = "Creates a new Garden module."; + this.description = dedent ` + Creates a new Garden module of the given type + + Examples: + + garden create module # creates a new module in the current directory (module name defaults to directory name) + garden create module my-module # creates a new module in my-module directory + garden create module --type=container # creates a new container module + garden create module --name=my-module # creates a new module in current directory and names it my-module + `; + this.noProject = true; + this.arguments = createModuleArguments; + this.options = createModuleOptions; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + let errors = []; + const moduleRoot = path_1.join(garden.projectRoot, (args["module-dir"] || "").trim()); + const moduleName = common_1.validate(opts.name || path_1.basename(moduleRoot), common_1.joiIdentifier(), { context: "module name" }); + yield fs_extra_1.ensureDir(moduleRoot); + garden.log.header({ emoji: "house_with_garden", command: "create" }); + garden.log.info(`Initializing new module ${moduleName}`); + let type; + if (opts.type) { + // Type passed as parameter + type = opts.type; + if (!config_templates_1.availableModuleTypes.includes(type)) { + throw new exceptions_1.ParameterError("Module type not available", {}); + } + } + else { + // Prompt for type + garden.log.info("---------"); + garden.log.stop(); + type = (yield prompts_1.prompts.addConfigForModule(moduleName)).type; + garden.log.info("---------"); + if (!type) { + return { result: {} }; + } + } + const module = helpers_1.prepareNewModuleConfig(moduleName, type, moduleRoot); + try { + yield helpers_1.dumpConfig(module, config_templates_1.moduleSchema, garden.log); + } + catch (err) { + errors.push(err); + } + return { + result: { module }, + errors, + }; + }); + } +} +exports.CreateModuleCommand = CreateModuleCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/create/project.d.ts b/garden-service/build/commands/create/project.d.ts new file mode 100644 index 00000000000..5d049665c62 --- /dev/null +++ b/garden-service/build/commands/create/project.d.ts @@ -0,0 +1,34 @@ +import { Command, CommandParams, CommandResult, StringParameter, PathsParameter } from "../base"; +import { ModuleConfigOpts, ProjectConfigOpts } from "./config-templates"; +declare const createProjectOptions: { + "module-dirs": PathsParameter; + name: StringParameter; +}; +declare const createProjectArguments: { + "project-dir": StringParameter; +}; +declare type Args = typeof createProjectArguments; +declare type Opts = typeof createProjectOptions; +interface CreateProjectResult extends CommandResult { + result: { + projectConfig: ProjectConfigOpts; + moduleConfigs: ModuleConfigOpts[]; + }; +} +export declare class CreateProjectCommand extends Command { + name: string; + alias: string; + help: string; + description: string; + noProject: boolean; + arguments: { + "project-dir": StringParameter; + }; + options: { + "module-dirs": PathsParameter; + name: StringParameter; + }; + action({ garden, args, opts }: CommandParams): Promise; +} +export {}; +//# sourceMappingURL=project.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/create/project.js b/garden-service/build/commands/create/project.js new file mode 100644 index 00000000000..80a8107d11a --- /dev/null +++ b/garden-service/build/commands/create/project.js @@ -0,0 +1,143 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const fs_extra_1 = require("fs-extra"); +const Bluebird = require("bluebird"); +const dedent = require("dedent"); +const terminalLink = require("terminal-link"); +const base_1 = require("../base"); +const helpers_1 = require("./helpers"); +const prompts_1 = require("./prompts"); +const config_templates_1 = require("./config-templates"); +const util_1 = require("../../util/util"); +const common_1 = require("../../config/common"); +const project_1 = require("../../config/project"); +const createProjectOptions = { + "module-dirs": new base_1.PathsParameter({ + help: "Relative path to modules directory. Use comma as a separator to specify multiple directories", + }), + name: new base_1.StringParameter({ + help: "Assigns a custom name to the project. (Defaults to name of the current directory.)", + }), +}; +const createProjectArguments = { + "project-dir": new base_1.StringParameter({ + help: "Directory of the project. (Defaults to current directory.)", + }), +}; +const flatten = (acc, val) => acc.concat(val); +class CreateProjectCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "project"; + this.alias = "p"; + this.help = "Creates a new Garden project."; + this.description = dedent ` + The 'create project' command walks the user through setting up a new Garden project and + generates scaffolding based on user input. + + Examples: + + garden create project # creates a new Garden project in the current directory (project name defaults to + directory name) + garden create project my-project # creates a new Garden project in my-project directory + garden create project --module-dirs=path/to/modules1,path/to/modules2 + # creates a new Garden project and looks for pre-existing modules in the modules1 and modules2 directories + garden create project --name my-project + # creates a new Garden project in the current directory and names it my-project + `; + this.noProject = true; + this.arguments = createProjectArguments; + this.options = createProjectOptions; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + let moduleConfigs = []; + let errors = []; + const projectRoot = args["project-dir"] ? path_1.join(garden.projectRoot, args["project-dir"].trim()) : garden.projectRoot; + const moduleParentDirs = yield Bluebird.map(opts["module-dirs"] || [], (dir) => path_1.resolve(projectRoot, dir)); + const projectName = common_1.validate(opts.name || path_1.basename(projectRoot), common_1.joiIdentifier(), { context: "project name" }); + yield fs_extra_1.ensureDir(projectRoot); + garden.log.header({ emoji: "house_with_garden", command: "create" }); + garden.log.info(`Initializing new Garden project ${projectName}`); + garden.log.info("---------"); + // Stop logger while prompting + garden.log.stop(); + if (moduleParentDirs.length > 0) { + // If module-dirs option provided we scan for modules in the parent dir(s) and add them one by one + moduleConfigs = (yield Bluebird.mapSeries(moduleParentDirs, (parentDir) => __awaiter(this, void 0, void 0, function* () { + const moduleNames = yield util_1.getChildDirNames(parentDir); + return Bluebird.reduce(moduleNames, (acc, moduleName) => __awaiter(this, void 0, void 0, function* () { + const { type } = yield prompts_1.prompts.addConfigForModule(moduleName); + if (type) { + acc.push(helpers_1.prepareNewModuleConfig(moduleName, type, path_1.join(parentDir, moduleName))); + } + return acc; + }), []); + }))) + .reduce(flatten, []) + .filter(m => m); + } + else { + // Otherwise we prompt the user for modules to add + moduleConfigs = (yield prompts_1.prompts.repeatAddModule()) + .map(({ name, type }) => helpers_1.prepareNewModuleConfig(name, type, path_1.join(projectRoot, name))); + } + garden.log.info("---------"); + const taskLog = garden.log.info({ msg: "Setting up project", status: "active" }); + for (const module of moduleConfigs) { + yield fs_extra_1.ensureDir(module.path); + try { + yield helpers_1.dumpConfig(module, config_templates_1.moduleSchema, garden.log); + } + catch (err) { + errors.push(err); + } + } + const projectConfig = { + path: projectRoot, + name: projectName, + config: config_templates_1.projectTemplate(projectName, moduleConfigs.map(module => module.type)), + }; + try { + yield helpers_1.dumpConfig(projectConfig, project_1.projectSchema, garden.log); + } + catch (err) { + errors.push(err); + } + if (errors.length === 0) { + taskLog.setSuccess(); + } + else { + taskLog.setWarn({ msg: "Finished with errors", append: true }); + } + const docs = terminalLink("docs", "https://docs.garden.io"); + garden.log.info(`Project created! Be sure to check out our ${docs} for how to get sarted!`); + return { + result: { + moduleConfigs, + projectConfig, + }, + errors, + }; + }); + } +} +exports.CreateProjectCommand = CreateProjectCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["commands/create/project.ts"],"names":[],"mappings":"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","file":"commands/create/project.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { resolve, join, basename } from \"path\"\nimport { ensureDir } from \"fs-extra\"\nimport Bluebird = require(\"bluebird\")\nimport dedent = require(\"dedent\")\nimport terminalLink = require(\"terminal-link\")\n\nimport {\n  Command,\n  CommandParams,\n  CommandResult,\n  StringParameter,\n  PathsParameter,\n} from \"../base\"\nimport { GardenBaseError } from \"../../exceptions\"\nimport {\n  prepareNewModuleConfig,\n  dumpConfig,\n} from \"./helpers\"\nimport { prompts } from \"./prompts\"\nimport {\n  projectTemplate,\n  ModuleConfigOpts,\n  ProjectConfigOpts,\n  moduleSchema,\n} from \"./config-templates\"\nimport { getChildDirNames } from \"../../util/util\"\nimport { validate, joiIdentifier } from \"../../config/common\"\nimport { projectSchema } from \"../../config/project\"\n\nconst createProjectOptions = {\n  \"module-dirs\": new PathsParameter({\n    help: \"Relative path to modules directory. Use comma as a separator to specify multiple directories\",\n  }),\n  name: new StringParameter({\n    help: \"Assigns a custom name to the project. (Defaults to name of the current directory.)\",\n  }),\n}\n\nconst createProjectArguments = {\n  \"project-dir\": new StringParameter({\n    help: \"Directory of the project. (Defaults to current directory.)\",\n  }),\n}\n\ntype Args = typeof createProjectArguments\ntype Opts = typeof createProjectOptions\n\nconst flatten = (acc, val) => acc.concat(val)\n\ninterface CreateProjectResult extends CommandResult {\n  result: {\n    projectConfig: ProjectConfigOpts,\n    moduleConfigs: ModuleConfigOpts[],\n  }\n}\n\nexport class CreateProjectCommand extends Command<Args, Opts> {\n  name = \"project\"\n  alias = \"p\"\n  help = \"Creates a new Garden project.\"\n\n  description = dedent`\n    The 'create project' command walks the user through setting up a new Garden project and\n    generates scaffolding based on user input.\n\n    Examples:\n\n        garden create project # creates a new Garden project in the current directory (project name defaults to\n        directory name)\n        garden create project my-project # creates a new Garden project in my-project directory\n        garden create project --module-dirs=path/to/modules1,path/to/modules2\n        # creates a new Garden project and looks for pre-existing modules in the modules1 and modules2 directories\n        garden create project --name my-project\n        # creates a new Garden project in the current directory and names it my-project\n  `\n\n  noProject = true\n  arguments = createProjectArguments\n  options = createProjectOptions\n\n  async action({ garden, args, opts }: CommandParams<Args, Opts>): Promise<CreateProjectResult> {\n    let moduleConfigs: ModuleConfigOpts[] = []\n    let errors: GardenBaseError[] = []\n\n    const projectRoot = args[\"project-dir\"] ? join(garden.projectRoot, args[\"project-dir\"].trim()) : garden.projectRoot\n    const moduleParentDirs = await Bluebird.map(opts[\"module-dirs\"] || [], (dir: string) => resolve(projectRoot, dir))\n    const projectName = validate(\n      opts.name || basename(projectRoot),\n      joiIdentifier(),\n      { context: \"project name\" },\n    )\n\n    await ensureDir(projectRoot)\n\n    garden.log.header({ emoji: \"house_with_garden\", command: \"create\" })\n    garden.log.info(`Initializing new Garden project ${projectName}`)\n    garden.log.info(\"---------\")\n    // Stop logger while prompting\n    garden.log.stop()\n\n    if (moduleParentDirs.length > 0) {\n      // If module-dirs option provided we scan for modules in the parent dir(s) and add them one by one\n      moduleConfigs = (await Bluebird.mapSeries(moduleParentDirs, async parentDir => {\n        const moduleNames = await getChildDirNames(parentDir)\n\n        return Bluebird.reduce(moduleNames, async (acc: ModuleConfigOpts[], moduleName: string) => {\n          const { type } = await prompts.addConfigForModule(moduleName)\n          if (type) {\n            acc.push(prepareNewModuleConfig(moduleName, type, join(parentDir, moduleName)))\n          }\n          return acc\n        }, [])\n      }))\n        .reduce(flatten, [])\n        .filter(m => m)\n    } else {\n      // Otherwise we prompt the user for modules to add\n      moduleConfigs = (await prompts.repeatAddModule())\n        .map(({ name, type }) => prepareNewModuleConfig(name, type, join(projectRoot, name)))\n    }\n\n    garden.log.info(\"---------\")\n    const taskLog = garden.log.info({ msg: \"Setting up project\", status: \"active\" })\n\n    for (const module of moduleConfigs) {\n      await ensureDir(module.path)\n      try {\n        await dumpConfig(module, moduleSchema, garden.log)\n      } catch (err) {\n        errors.push(err)\n      }\n    }\n\n    const projectConfig: ProjectConfigOpts = {\n      path: projectRoot,\n      name: projectName,\n      config: projectTemplate(projectName, moduleConfigs.map(module => module.type)),\n    }\n\n    try {\n      await dumpConfig(projectConfig, projectSchema, garden.log)\n    } catch (err) {\n      errors.push(err)\n    }\n\n    if (errors.length === 0) {\n      taskLog.setSuccess()\n    } else {\n      taskLog.setWarn({ msg: \"Finished with errors\", append: true })\n    }\n\n    const docs = terminalLink(\"docs\", \"https://docs.garden.io\")\n    garden.log.info(`Project created! Be sure to check out our ${docs} for how to get sarted!`)\n\n    return {\n      result: {\n        moduleConfigs,\n        projectConfig,\n      },\n      errors,\n    }\n  }\n}\n"]} diff --git a/garden-service/build/commands/create/prompts.d.ts b/garden-service/build/commands/create/prompts.d.ts new file mode 100644 index 00000000000..c31c7685612 --- /dev/null +++ b/garden-service/build/commands/create/prompts.d.ts @@ -0,0 +1,19 @@ +import * as inquirer from "inquirer"; +import { ModuleType } from "./config-templates"; +export interface ModuleTypeChoice extends inquirer.objects.ChoiceOption { + value: ModuleType; +} +export interface ModuleTypeMap { + type: ModuleType; +} +export interface ModuleTypeAndName extends ModuleTypeMap { + name: string; +} +export interface Prompts { + addConfigForModule: (...args: any[]) => Promise; + addModule: (...args: any[]) => Promise; + repeatAddModule: (...args: any[]) => Promise; +} +export declare function repeatAddModule(): Promise; +export declare const prompts: Prompts; +//# sourceMappingURL=prompts.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/create/prompts.js b/garden-service/build/commands/create/prompts.js new file mode 100644 index 00000000000..13de190d867 --- /dev/null +++ b/garden-service/build/commands/create/prompts.js @@ -0,0 +1,121 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const inquirer = require("inquirer"); +const Joi = require("joi"); +const chalk_1 = require("chalk"); +const common_1 = require("../../config/common"); +const moduleTypeChoices = [ + { + name: "container", + value: "container", + }, + { + name: `google-cloud-function (${chalk_1.default.red.italic("experimental")})`, + value: "google-cloud-function", + }, + { + name: `npm package (${chalk_1.default.red.italic("experimental")})`, + value: "npm-package", + }, +]; +// Create config for an existing module +function addConfigForModule(dir) { + return __awaiter(this, void 0, void 0, function* () { + const qNames = { + ADD_MODULE: "addModule", + TYPE: "type", + }; + const questions = [ + { + name: qNames.ADD_MODULE, + message: `Add module config for ${chalk_1.default.italic(dir)}?`, + type: "confirm", + }, + { + name: qNames.TYPE, + message: "Module type", + choices: moduleTypeChoices, + when: ans => ans[qNames.ADD_MODULE], + type: "list", + }, + ]; + return yield inquirer.prompt(questions); + }); +} +// Create a new module with config +function addModule(addModuleMessage) { + return __awaiter(this, void 0, void 0, function* () { + const qNames = { + ADD_MODULE: "addModule", + NAME: "name", + TYPE: "type", + }; + const questions = [ + { + name: qNames.ADD_MODULE, + message: addModuleMessage, + type: "confirm", + }, + { + name: qNames.NAME, + message: "Enter module name", + type: "input", + validate: input => { + try { + Joi.attempt(input.trim(), common_1.joiIdentifier()); + } + catch (err) { + return `Invalid module name, please try again\nError: ${err.message}`; + } + return true; + }, + filter: input => input.trim(), + when: ans => ans[qNames.ADD_MODULE], + }, + { + name: qNames.TYPE, + message: "Module type", + choices: moduleTypeChoices, + when: ans => ans[qNames.NAME], + type: "list", + }, + ]; + return yield inquirer.prompt(questions); + }); +} +function repeatAddModule() { + return __awaiter(this, void 0, void 0, function* () { + let modules = []; + let addModuleMessage = "Would you like to add a module to your project?"; + let ans = yield addModule(addModuleMessage); + while (ans.type) { + modules.push({ name: ans.name, type: ans.type }); + addModuleMessage = `Add another module? (current modules: ${modules.map(m => m.name).join(", ")})`; + ans = yield addModule(addModuleMessage); + } + return modules; + }); +} +exports.repeatAddModule = repeatAddModule; +exports.prompts = { + addConfigForModule, + addModule, + repeatAddModule, +}; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["commands/create/prompts.ts"],"names":[],"mappings":"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","file":"commands/create/prompts.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as inquirer from \"inquirer\"\nimport * as Joi from \"joi\"\nimport chalk from \"chalk\"\n\nimport { joiIdentifier } from \"../../config/common\"\nimport { ModuleType } from \"./config-templates\"\n\nexport interface ModuleTypeChoice extends inquirer.objects.ChoiceOption {\n  value: ModuleType\n}\n\nexport interface ModuleTypeMap {\n  type: ModuleType\n}\n\nexport interface ModuleTypeAndName extends ModuleTypeMap {\n  name: string\n}\n\nexport interface Prompts {\n  addConfigForModule: (...args: any[]) => Promise<ModuleTypeMap>\n  addModule: (...args: any[]) => Promise<ModuleTypeAndName>\n  repeatAddModule: (...args: any[]) => Promise<ModuleTypeAndName[]>\n}\n\nconst moduleTypeChoices: ModuleTypeChoice[] = [\n  {\n    name: \"container\",\n    value: \"container\",\n  },\n  {\n    name: `google-cloud-function (${chalk.red.italic(\"experimental\")})`,\n    value: \"google-cloud-function\",\n  },\n  {\n    name: `npm package (${chalk.red.italic(\"experimental\")})`,\n    value: \"npm-package\",\n  },\n]\n\n// Create config for an existing module\nasync function addConfigForModule(dir: string): Promise<ModuleTypeMap> {\n  const qNames = {\n    ADD_MODULE: \"addModule\",\n    TYPE: \"type\",\n  }\n  const questions: inquirer.Questions = [\n    {\n      name: qNames.ADD_MODULE,\n      message: `Add module config for ${chalk.italic(dir)}?`,\n      type: \"confirm\",\n    },\n    {\n      name: qNames.TYPE,\n      message: \"Module type\",\n      choices: moduleTypeChoices,\n      when: ans => ans[qNames.ADD_MODULE],\n      type: \"list\",\n    },\n  ]\n  return await inquirer.prompt(questions) as ModuleTypeMap\n}\n\n// Create a new module with config\nasync function addModule(addModuleMessage: string): Promise<ModuleTypeAndName> {\n  const qNames = {\n    ADD_MODULE: \"addModule\",\n    NAME: \"name\",\n    TYPE: \"type\",\n  }\n  const questions: inquirer.Questions = [\n    {\n      name: qNames.ADD_MODULE,\n      message: addModuleMessage,\n      type: \"confirm\",\n    },\n    {\n      name: qNames.NAME,\n      message: \"Enter module name\",\n      type: \"input\",\n      validate: input => {\n        try {\n          Joi.attempt(input.trim(), joiIdentifier())\n        } catch (err) {\n          return `Invalid module name, please try again\\nError: ${err.message}`\n        }\n        return true\n      },\n      filter: input => input.trim(),\n      when: ans => ans[qNames.ADD_MODULE],\n    },\n    {\n      name: qNames.TYPE,\n      message: \"Module type\",\n      choices: moduleTypeChoices,\n      when: ans => ans[qNames.NAME],\n      type: \"list\",\n    },\n  ]\n  return await inquirer.prompt(questions) as ModuleTypeAndName\n}\n\nexport async function repeatAddModule(): Promise<ModuleTypeAndName[]> {\n  let modules: ModuleTypeAndName[] = []\n  let addModuleMessage = \"Would you like to add a module to your project?\"\n  let ans = await addModule(addModuleMessage)\n\n  while (ans.type) {\n    modules.push({ name: ans.name, type: ans.type })\n    addModuleMessage = `Add another module? (current modules: ${modules.map(m => m.name).join(\", \")})`\n    ans = await addModule(addModuleMessage)\n  }\n  return modules\n}\n\nexport const prompts: Prompts = {\n  addConfigForModule,\n  addModule,\n  repeatAddModule,\n}\n"]} diff --git a/garden-service/build/commands/delete.d.ts b/garden-service/build/commands/delete.d.ts new file mode 100644 index 00000000000..e00120fa5cb --- /dev/null +++ b/garden-service/build/commands/delete.d.ts @@ -0,0 +1,46 @@ +import { DeleteSecretResult, EnvironmentStatusMap } from "../types/plugin/outputs"; +import { Command, CommandResult, CommandParams, StringParameter, StringsParameter } from "./base"; +export declare class DeleteCommand extends Command { + name: string; + alias: string; + help: string; + subCommands: (typeof DeleteSecretCommand | typeof DeleteEnvironmentCommand | typeof DeleteServiceCommand)[]; + action(): Promise<{}>; +} +declare const deleteSecretArgs: { + provider: StringParameter; + key: StringParameter; +}; +declare type DeleteSecretArgs = typeof deleteSecretArgs; +export declare class DeleteSecretCommand extends Command { + name: string; + help: string; + description: string; + arguments: { + provider: StringParameter; + key: StringParameter; + }; + action({ garden, args }: CommandParams): Promise>; +} +export declare class DeleteEnvironmentCommand extends Command { + name: string; + alias: string; + help: string; + description: string; + action({ garden }: CommandParams): Promise>; +} +declare const deleteServiceArgs: { + service: StringsParameter; +}; +declare type DeleteServiceArgs = typeof deleteServiceArgs; +export declare class DeleteServiceCommand extends Command { + name: string; + help: string; + arguments: { + service: StringsParameter; + }; + description: string; + action({ garden, args }: CommandParams): Promise; +} +export {}; +//# sourceMappingURL=delete.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/delete.js b/garden-service/build/commands/delete.js new file mode 100644 index 00000000000..2007378b1af --- /dev/null +++ b/garden-service/build/commands/delete.js @@ -0,0 +1,145 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const base_1 = require("./base"); +const exceptions_1 = require("../exceptions"); +const dedent = require("dedent"); +class DeleteCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "delete"; + this.alias = "del"; + this.help = "Delete configuration or objects."; + this.subCommands = [ + DeleteSecretCommand, + DeleteEnvironmentCommand, + DeleteServiceCommand, + ]; + } + action() { + return __awaiter(this, void 0, void 0, function* () { return {}; }); + } +} +exports.DeleteCommand = DeleteCommand; +const deleteSecretArgs = { + provider: new base_1.StringParameter({ + help: "The name of the provider to remove the secret from.", + required: true, + }), + key: new base_1.StringParameter({ + help: "The key of the configuration variable. Separate with dots to get a nested key (e.g. key.nested).", + required: true, + }), +}; +class DeleteSecretCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "secret"; + this.help = "Delete a secret from the environment."; + this.description = dedent ` + Returns with an error if the provided key could not be found by the provider. + + Examples: + + garden delete secret kubernetes somekey + garden del secret local-kubernetes some-other-key + `; + this.arguments = deleteSecretArgs; + } + action({ garden, args }) { + return __awaiter(this, void 0, void 0, function* () { + const key = args.key; + const result = yield garden.actions.deleteSecret({ pluginName: args.provider, key }); + if (result.found) { + garden.log.info(`Deleted config key ${args.key}`); + } + else { + throw new exceptions_1.NotFoundError(`Could not find config key ${args.key}`, { key }); + } + return { result }; + }); + } +} +exports.DeleteSecretCommand = DeleteSecretCommand; +class DeleteEnvironmentCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "environment"; + this.alias = "env"; + this.help = "Deletes a running environment."; + this.description = dedent ` + This will trigger providers to clear up any deployments in a Garden environment and reset it. + When you then run \`garden init\`, the environment will be reconfigured. + + This can be useful if you find the environment to be in an inconsistent state, or need/want to free up + resources. + `; + } + action({ garden }) { + return __awaiter(this, void 0, void 0, function* () { + const { name } = garden.environment; + garden.log.header({ emoji: "skull_and_crossbones", command: `Deleting ${name} environment` }); + const result = yield garden.actions.cleanupEnvironment({}); + garden.log.finish(); + return { result }; + }); + } +} +exports.DeleteEnvironmentCommand = DeleteEnvironmentCommand; +const deleteServiceArgs = { + service: new base_1.StringsParameter({ + help: "The name of the service(s) to delete. Use comma as separator to specify multiple services.", + required: true, + }), +}; +class DeleteServiceCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "service"; + this.help = "Deletes a running service."; + this.arguments = deleteServiceArgs; + this.description = dedent ` + Deletes (i.e. un-deploys) the specified services. Note that this command does not take into account any + services depending on the deleted service, and might therefore leave the project in an unstable state. + Running \`garden deploy\` will re-deploy any missing services. + + Examples: + + garden delete service my-service # deletes my-service + `; + } + action({ garden, args }) { + return __awaiter(this, void 0, void 0, function* () { + const services = yield garden.getServices(args.service); + if (services.length === 0) { + garden.log.warn({ msg: "No services found. Aborting." }); + return { result: {} }; + } + garden.log.header({ emoji: "skull_and_crossbones", command: `Delete service` }); + const result = {}; + yield Bluebird.map(services, (service) => __awaiter(this, void 0, void 0, function* () { + result[service.name] = yield garden.actions.deleteService({ service }); + })); + garden.log.finish(); + return { result }; + }); + } +} +exports.DeleteServiceCommand = DeleteServiceCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["commands/delete.ts"],"names":[],"mappings":"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","file":"commands/delete.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Bluebird from \"bluebird\"\nimport {\n  DeleteSecretResult,\n  EnvironmentStatusMap,\n} from \"../types/plugin/outputs\"\nimport {\n  Command,\n  CommandResult,\n  CommandParams,\n  StringParameter,\n  StringsParameter,\n} from \"./base\"\nimport { NotFoundError } from \"../exceptions\"\nimport dedent = require(\"dedent\")\nimport { ServiceStatus } from \"../types/service\"\n\nexport class DeleteCommand extends Command {\n  name = \"delete\"\n  alias = \"del\"\n  help = \"Delete configuration or objects.\"\n\n  subCommands = [\n    DeleteSecretCommand,\n    DeleteEnvironmentCommand,\n    DeleteServiceCommand,\n  ]\n\n  async action() { return {} }\n}\n\nconst deleteSecretArgs = {\n  provider: new StringParameter({\n    help: \"The name of the provider to remove the secret from.\",\n    required: true,\n  }),\n  key: new StringParameter({\n    help: \"The key of the configuration variable. Separate with dots to get a nested key (e.g. key.nested).\",\n    required: true,\n  }),\n}\n\ntype DeleteSecretArgs = typeof deleteSecretArgs\n\nexport class DeleteSecretCommand extends Command<typeof deleteSecretArgs> {\n  name = \"secret\"\n  help = \"Delete a secret from the environment.\"\n\n  description = dedent`\n    Returns with an error if the provided key could not be found by the provider.\n\n    Examples:\n\n        garden delete secret kubernetes somekey\n        garden del secret local-kubernetes some-other-key\n  `\n\n  arguments = deleteSecretArgs\n\n  async action({ garden, args }: CommandParams<DeleteSecretArgs>): Promise<CommandResult<DeleteSecretResult>> {\n    const key = args.key!\n    const result = await garden.actions.deleteSecret({ pluginName: args.provider!, key })\n\n    if (result.found) {\n      garden.log.info(`Deleted config key ${args.key}`)\n    } else {\n      throw new NotFoundError(`Could not find config key ${args.key}`, { key })\n    }\n\n    return { result }\n  }\n}\n\nexport class DeleteEnvironmentCommand extends Command {\n  name = \"environment\"\n  alias = \"env\"\n  help = \"Deletes a running environment.\"\n\n  description = dedent`\n    This will trigger providers to clear up any deployments in a Garden environment and reset it.\n    When you then run \\`garden init\\`, the environment will be reconfigured.\n\n    This can be useful if you find the environment to be in an inconsistent state, or need/want to free up\n    resources.\n  `\n\n  async action({ garden }: CommandParams): Promise<CommandResult<EnvironmentStatusMap>> {\n    const { name } = garden.environment\n    garden.log.header({ emoji: \"skull_and_crossbones\", command: `Deleting ${name} environment` })\n\n    const result = await garden.actions.cleanupEnvironment({})\n\n    garden.log.finish()\n\n    return { result }\n  }\n}\n\nconst deleteServiceArgs = {\n  service: new StringsParameter({\n    help: \"The name of the service(s) to delete. Use comma as separator to specify multiple services.\",\n    required: true,\n  }),\n}\ntype DeleteServiceArgs = typeof deleteServiceArgs\n\nexport class DeleteServiceCommand extends Command {\n  name = \"service\"\n  help = \"Deletes a running service.\"\n  arguments = deleteServiceArgs\n\n  description = dedent`\n    Deletes (i.e. un-deploys) the specified services. Note that this command does not take into account any\n    services depending on the deleted service, and might therefore leave the project in an unstable state.\n    Running \\`garden deploy\\` will re-deploy any missing services.\n\n    Examples:\n\n        garden delete service my-service # deletes my-service\n  `\n\n  async action({ garden, args }: CommandParams<DeleteServiceArgs>): Promise<CommandResult> {\n    const services = await garden.getServices(args.service)\n\n    if (services.length === 0) {\n      garden.log.warn({ msg: \"No services found. Aborting.\" })\n      return { result: {} }\n    }\n\n    garden.log.header({ emoji: \"skull_and_crossbones\", command: `Delete service` })\n\n    const result: { [key: string]: ServiceStatus } = {}\n\n    await Bluebird.map(services, async service => {\n      result[service.name] = await garden.actions.deleteService({ service })\n    })\n\n    garden.log.finish()\n    return { result }\n  }\n}\n"]} diff --git a/garden-service/build/commands/deploy.d.ts b/garden-service/build/commands/deploy.d.ts new file mode 100644 index 00000000000..0a41ba26a08 --- /dev/null +++ b/garden-service/build/commands/deploy.d.ts @@ -0,0 +1,28 @@ +import { BooleanParameter, Command, CommandParams, CommandResult, StringsParameter } from "./base"; +import { TaskResults } from "../task-graph"; +declare const deployArgs: { + service: StringsParameter; +}; +declare const deployOpts: { + force: BooleanParameter; + "force-build": BooleanParameter; + watch: BooleanParameter; +}; +declare type Args = typeof deployArgs; +declare type Opts = typeof deployOpts; +export declare class DeployCommand extends Command { + name: string; + help: string; + description: string; + arguments: { + service: StringsParameter; + }; + options: { + force: BooleanParameter; + "force-build": BooleanParameter; + watch: BooleanParameter; + }; + action({ garden, args, opts }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=deploy.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/deploy.js b/garden-service/build/commands/deploy.js new file mode 100644 index 00000000000..1596e95e3e7 --- /dev/null +++ b/garden-service/build/commands/deploy.js @@ -0,0 +1,98 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("./base"); +const deploy_1 = require("../tasks/deploy"); +const process_1 = require("../process"); +const util_1 = require("../util/util"); +const deployArgs = { + service: new base_1.StringsParameter({ + help: "The name of the service(s) to deploy (skip to deploy all services). " + + "Use comma as separator to specify multiple services.", + }), +}; +const deployOpts = { + force: new base_1.BooleanParameter({ help: "Force redeploy of service(s)." }), + "force-build": new base_1.BooleanParameter({ help: "Force rebuild of module(s)." }), + watch: new base_1.BooleanParameter({ help: "Watch for changes in module(s) and auto-deploy.", alias: "w" }), +}; +class DeployCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "deploy"; + this.help = "Deploy service(s) to your environment."; + this.description = ` + Deploys all or specified services, taking into account service dependency order. + Also builds modules and dependencies if needed. + + Optionally stays running and automatically re-builds and re-deploys services if their module source + (or their dependencies' sources) change. + + Examples: + + garden deploy # deploy all modules in the project + garden deploy my-service # only deploy my-service + garden deploy --force # force re-deploy of modules, even if they're already deployed + garden deploy --watch # watch for changes to code + garden deploy --env stage # deploy your services to an environment called stage + `; + this.arguments = deployArgs; + this.options = deployOpts; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + const services = yield garden.getServices(args.service); + const serviceNames = util_1.getNames(services); + if (services.length === 0) { + garden.log.warn({ msg: "No services found. Aborting." }); + return { result: {} }; + } + garden.log.header({ emoji: "rocket", command: "Deploy" }); + // TODO: make this a task + yield garden.actions.prepareEnvironment({}); + const results = yield process_1.processServices({ + garden, + services, + watch: opts.watch, + handler: (module) => __awaiter(this, void 0, void 0, function* () { + return deploy_1.getDeployTasks({ + garden, + module, + serviceNames, + force: opts.force, + forceBuild: opts["force-build"], + includeDependants: false, + }); + }), + changeHandler: (module) => __awaiter(this, void 0, void 0, function* () { + return deploy_1.getDeployTasks({ + garden, + module, + serviceNames, + force: true, + forceBuild: true, + includeDependants: true, + }); + }), + }); + return base_1.handleTaskResults(garden, "deploy", results); + }); + } +} +exports.DeployCommand = DeployCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/dev.d.ts b/garden-service/build/commands/dev.d.ts new file mode 100644 index 00000000000..4d1dbc941cc --- /dev/null +++ b/garden-service/build/commands/dev.d.ts @@ -0,0 +1,8 @@ +import { Command, CommandResult, CommandParams } from "./base"; +export declare class DevCommand extends Command { + name: string; + help: string; + description: string; + action({ garden }: CommandParams): Promise; +} +//# sourceMappingURL=dev.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/dev.js b/garden-service/build/commands/dev.js new file mode 100644 index 00000000000..a9adf3743a3 --- /dev/null +++ b/garden-service/build/commands/dev.js @@ -0,0 +1,108 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const chalk_1 = require("chalk"); +const lodash_1 = require("lodash"); +const moment = require("moment"); +const path_1 = require("path"); +const build_1 = require("../tasks/build"); +const base_1 = require("./base"); +const constants_1 = require("../constants"); +const process_1 = require("../process"); +const fs_extra_1 = require("fs-extra"); +const test_1 = require("./test"); +const watch_1 = require("../watch"); +const deploy_1 = require("../tasks/deploy"); +const ansiBannerPath = path_1.join(constants_1.STATIC_DIR, "garden-banner-2.txt"); +// TODO: allow limiting to certain modules and/or services +class DevCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "dev"; + this.help = "Starts the garden development console."; + this.description = ` + The Garden dev console is a combination of the \`build\`, \`deploy\` and \`test\` commands. + It builds, deploys and tests all your modules and services, and re-builds, re-deploys and re-tests + as you modify the code. + + Examples: + + garden dev + `; + } + action({ garden }) { + return __awaiter(this, void 0, void 0, function* () { + // print ANSI banner image + const data = yield fs_extra_1.readFile(ansiBannerPath); + console.log(data.toString()); + garden.log.info(chalk_1.default.gray.italic(`\nGood ${getGreetingTime()}! Let's get your environment wired up...\n`)); + yield garden.actions.prepareEnvironment({}); + const autoReloadDependants = yield watch_1.computeAutoReloadDependants(garden); + const modules = yield garden.getModules(); + if (modules.length === 0) { + if (modules.length === 0) { + garden.log.info({ msg: "No modules found in project." }); + } + garden.log.info({ msg: "Aborting..." }); + return {}; + } + const tasksForModule = (watch) => { + return (module) => __awaiter(this, void 0, void 0, function* () { + const testModules = watch + ? (yield watch_1.withDependants(garden, [module], autoReloadDependants)) + : [module]; + const testTasks = lodash_1.flatten(yield Bluebird.map(testModules, m => test_1.getTestTasks({ garden, module: m }))); + const deployTasks = yield deploy_1.getDeployTasks({ + garden, module, force: watch, forceBuild: watch, includeDependants: watch, + }); + const tasks = testTasks.concat(deployTasks); + if (tasks.length === 0) { + return [new build_1.BuildTask({ garden, module, force: watch })]; + } + else { + return tasks; + } + }); + }; + yield process_1.processModules({ + garden, + modules, + watch: true, + handler: tasksForModule(false), + changeHandler: tasksForModule(true), + }); + return {}; + }); + } +} +exports.DevCommand = DevCommand; +function getGreetingTime() { + const m = moment(); + const currentHour = parseFloat(m.format("HH")); + if (currentHour >= 17) { + return "evening"; + } + else if (currentHour >= 12) { + return "afternoon"; + } + else { + return "morning"; + } +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbW1hbmRzL2Rldi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7O0FBRUgscUNBQW9DO0FBQ3BDLGlDQUF5QjtBQUN6QixtQ0FBZ0M7QUFDaEMsaUNBQWlDO0FBQ2pDLCtCQUEyQjtBQUUzQiwwQ0FBMEM7QUFFMUMsaUNBSWU7QUFDZiw0Q0FBeUM7QUFDekMsd0NBQTJDO0FBQzNDLHVDQUFtQztBQUVuQyxpQ0FBcUM7QUFDckMsb0NBQXNFO0FBQ3RFLDRDQUFnRDtBQUVoRCxNQUFNLGNBQWMsR0FBRyxXQUFJLENBQUMsc0JBQVUsRUFBRSxxQkFBcUIsQ0FBQyxDQUFBO0FBRTlELDBEQUEwRDtBQUMxRCxNQUFhLFVBQVcsU0FBUSxjQUFPO0lBQXZDOztRQUNFLFNBQUksR0FBRyxLQUFLLENBQUE7UUFDWixTQUFJLEdBQUcsd0NBQXdDLENBQUE7UUFFL0MsZ0JBQVcsR0FBRzs7Ozs7Ozs7R0FRYixDQUFBO0lBd0RILENBQUM7SUF0RE8sTUFBTSxDQUFDLEVBQUUsTUFBTSxFQUFpQjs7WUFDcEMsMEJBQTBCO1lBQzFCLE1BQU0sSUFBSSxHQUFHLE1BQU0sbUJBQVEsQ0FBQyxjQUFjLENBQUMsQ0FBQTtZQUMzQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFBO1lBRTVCLE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLGVBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLFVBQVUsZUFBZSxFQUFFLDRDQUE0QyxDQUFDLENBQUMsQ0FBQTtZQUUzRyxNQUFNLE1BQU0sQ0FBQyxPQUFPLENBQUMsa0JBQWtCLENBQUMsRUFBRSxDQUFDLENBQUE7WUFFM0MsTUFBTSxvQkFBb0IsR0FBRyxNQUFNLG1DQUEyQixDQUFDLE1BQU0sQ0FBQyxDQUFBO1lBQ3RFLE1BQU0sT0FBTyxHQUFHLE1BQU0sTUFBTSxDQUFDLFVBQVUsRUFBRSxDQUFBO1lBRXpDLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7Z0JBQ3hCLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7b0JBQ3hCLE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLDhCQUE4QixFQUFFLENBQUMsQ0FBQTtpQkFDekQ7Z0JBQ0QsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxHQUFHLEVBQUUsYUFBYSxFQUFFLENBQUMsQ0FBQTtnQkFDdkMsT0FBTyxFQUFFLENBQUE7YUFDVjtZQUVELE1BQU0sY0FBYyxHQUFHLENBQUMsS0FBYyxFQUFFLEVBQUU7Z0JBQ3hDLE9BQU8sQ0FBTyxNQUFjLEVBQUUsRUFBRTtvQkFFOUIsTUFBTSxXQUFXLEdBQWEsS0FBSzt3QkFDakMsQ0FBQyxDQUFDLENBQUMsTUFBTSxzQkFBYyxDQUFDLE1BQU0sRUFBRSxDQUFDLE1BQU0sQ0FBQyxFQUFFLG9CQUFvQixDQUFDLENBQUM7d0JBQ2hFLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFBO29CQUVaLE1BQU0sU0FBUyxHQUFXLGdCQUFPLENBQUMsTUFBTSxRQUFRLENBQUMsR0FBRyxDQUNsRCxXQUFXLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxtQkFBWSxDQUFDLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQTtvQkFFekQsTUFBTSxXQUFXLEdBQUcsTUFBTSx1QkFBYyxDQUFDO3dCQUN2QyxNQUFNLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxLQUFLO3FCQUMxRSxDQUFDLENBQUE7b0JBQ0YsTUFBTSxLQUFLLEdBQUcsU0FBUyxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQTtvQkFFM0MsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTt3QkFDdEIsT0FBTyxDQUFDLElBQUksaUJBQVMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQTtxQkFDekQ7eUJBQU07d0JBQ0wsT0FBTyxLQUFLLENBQUE7cUJBQ2I7Z0JBQ0gsQ0FBQyxDQUFBLENBQUE7WUFFSCxDQUFDLENBQUE7WUFFRCxNQUFNLHdCQUFjLENBQUM7Z0JBQ25CLE1BQU07Z0JBQ04sT0FBTztnQkFDUCxLQUFLLEVBQUUsSUFBSTtnQkFDWCxPQUFPLEVBQUUsY0FBYyxDQUFDLEtBQUssQ0FBQztnQkFDOUIsYUFBYSxFQUFFLGNBQWMsQ0FBQyxJQUFJLENBQUM7YUFDcEMsQ0FBQyxDQUFBO1lBRUYsT0FBTyxFQUFFLENBQUE7UUFDWCxDQUFDO0tBQUE7Q0FDRjtBQXBFRCxnQ0FvRUM7QUFFRCxTQUFTLGVBQWU7SUFDdEIsTUFBTSxDQUFDLEdBQUcsTUFBTSxFQUFFLENBQUE7SUFFbEIsTUFBTSxXQUFXLEdBQUcsVUFBVSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQTtJQUU5QyxJQUFJLFdBQVcsSUFBSSxFQUFFLEVBQUU7UUFDckIsT0FBTyxTQUFTLENBQUE7S0FDakI7U0FBTSxJQUFJLFdBQVcsSUFBSSxFQUFFLEVBQUU7UUFDNUIsT0FBTyxXQUFXLENBQUE7S0FDbkI7U0FBTTtRQUNMLE9BQU8sU0FBUyxDQUFBO0tBQ2pCO0FBQ0gsQ0FBQyIsImZpbGUiOiJjb21tYW5kcy9kZXYuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChDKSAyMDE4IEdhcmRlbiBUZWNobm9sb2dpZXMsIEluYy4gPGluZm9AZ2FyZGVuLmlvPlxuICpcbiAqIFRoaXMgU291cmNlIENvZGUgRm9ybSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGUgTW96aWxsYSBQdWJsaWNcbiAqIExpY2Vuc2UsIHYuIDIuMC4gSWYgYSBjb3B5IG9mIHRoZSBNUEwgd2FzIG5vdCBkaXN0cmlidXRlZCB3aXRoIHRoaXNcbiAqIGZpbGUsIFlvdSBjYW4gb2J0YWluIG9uZSBhdCBodHRwOi8vbW96aWxsYS5vcmcvTVBMLzIuMC8uXG4gKi9cblxuaW1wb3J0ICogYXMgQmx1ZWJpcmQgZnJvbSBcImJsdWViaXJkXCJcbmltcG9ydCBjaGFsayBmcm9tIFwiY2hhbGtcIlxuaW1wb3J0IHsgZmxhdHRlbiB9IGZyb20gXCJsb2Rhc2hcIlxuaW1wb3J0IG1vbWVudCA9IHJlcXVpcmUoXCJtb21lbnRcIilcbmltcG9ydCB7IGpvaW4gfSBmcm9tIFwicGF0aFwiXG5cbmltcG9ydCB7IEJ1aWxkVGFzayB9IGZyb20gXCIuLi90YXNrcy9idWlsZFwiXG5pbXBvcnQgeyBUYXNrIH0gZnJvbSBcIi4uL3Rhc2tzL2Jhc2VcIlxuaW1wb3J0IHtcbiAgQ29tbWFuZCxcbiAgQ29tbWFuZFJlc3VsdCxcbiAgQ29tbWFuZFBhcmFtcyxcbn0gZnJvbSBcIi4vYmFzZVwiXG5pbXBvcnQgeyBTVEFUSUNfRElSIH0gZnJvbSBcIi4uL2NvbnN0YW50c1wiXG5pbXBvcnQgeyBwcm9jZXNzTW9kdWxlcyB9IGZyb20gXCIuLi9wcm9jZXNzXCJcbmltcG9ydCB7IHJlYWRGaWxlIH0gZnJvbSBcImZzLWV4dHJhXCJcbmltcG9ydCB7IE1vZHVsZSB9IGZyb20gXCIuLi90eXBlcy9tb2R1bGVcIlxuaW1wb3J0IHsgZ2V0VGVzdFRhc2tzIH0gZnJvbSBcIi4vdGVzdFwiXG5pbXBvcnQgeyBjb21wdXRlQXV0b1JlbG9hZERlcGVuZGFudHMsIHdpdGhEZXBlbmRhbnRzIH0gZnJvbSBcIi4uL3dhdGNoXCJcbmltcG9ydCB7IGdldERlcGxveVRhc2tzIH0gZnJvbSBcIi4uL3Rhc2tzL2RlcGxveVwiXG5cbmNvbnN0IGFuc2lCYW5uZXJQYXRoID0gam9pbihTVEFUSUNfRElSLCBcImdhcmRlbi1iYW5uZXItMi50eHRcIilcblxuLy8gVE9ETzogYWxsb3cgbGltaXRpbmcgdG8gY2VydGFpbiBtb2R1bGVzIGFuZC9vciBzZXJ2aWNlc1xuZXhwb3J0IGNsYXNzIERldkNvbW1hbmQgZXh0ZW5kcyBDb21tYW5kIHtcbiAgbmFtZSA9IFwiZGV2XCJcbiAgaGVscCA9IFwiU3RhcnRzIHRoZSBnYXJkZW4gZGV2ZWxvcG1lbnQgY29uc29sZS5cIlxuXG4gIGRlc2NyaXB0aW9uID0gYFxuICAgIFRoZSBHYXJkZW4gZGV2IGNvbnNvbGUgaXMgYSBjb21iaW5hdGlvbiBvZiB0aGUgXFxgYnVpbGRcXGAsIFxcYGRlcGxveVxcYCBhbmQgXFxgdGVzdFxcYCBjb21tYW5kcy5cbiAgICBJdCBidWlsZHMsIGRlcGxveXMgYW5kIHRlc3RzIGFsbCB5b3VyIG1vZHVsZXMgYW5kIHNlcnZpY2VzLCBhbmQgcmUtYnVpbGRzLCByZS1kZXBsb3lzIGFuZCByZS10ZXN0c1xuICAgIGFzIHlvdSBtb2RpZnkgdGhlIGNvZGUuXG5cbiAgICBFeGFtcGxlczpcblxuICAgICAgICBnYXJkZW4gZGV2XG4gIGBcblxuICBhc3luYyBhY3Rpb24oeyBnYXJkZW4gfTogQ29tbWFuZFBhcmFtcyk6IFByb21pc2U8Q29tbWFuZFJlc3VsdD4ge1xuICAgIC8vIHByaW50IEFOU0kgYmFubmVyIGltYWdlXG4gICAgY29uc3QgZGF0YSA9IGF3YWl0IHJlYWRGaWxlKGFuc2lCYW5uZXJQYXRoKVxuICAgIGNvbnNvbGUubG9nKGRhdGEudG9TdHJpbmcoKSlcblxuICAgIGdhcmRlbi5sb2cuaW5mbyhjaGFsay5ncmF5Lml0YWxpYyhgXFxuR29vZCAke2dldEdyZWV0aW5nVGltZSgpfSEgTGV0J3MgZ2V0IHlvdXIgZW52aXJvbm1lbnQgd2lyZWQgdXAuLi5cXG5gKSlcblxuICAgIGF3YWl0IGdhcmRlbi5hY3Rpb25zLnByZXBhcmVFbnZpcm9ubWVudCh7fSlcblxuICAgIGNvbnN0IGF1dG9SZWxvYWREZXBlbmRhbnRzID0gYXdhaXQgY29tcHV0ZUF1dG9SZWxvYWREZXBlbmRhbnRzKGdhcmRlbilcbiAgICBjb25zdCBtb2R1bGVzID0gYXdhaXQgZ2FyZGVuLmdldE1vZHVsZXMoKVxuXG4gICAgaWYgKG1vZHVsZXMubGVuZ3RoID09PSAwKSB7XG4gICAgICBpZiAobW9kdWxlcy5sZW5ndGggPT09IDApIHtcbiAgICAgICAgZ2FyZGVuLmxvZy5pbmZvKHsgbXNnOiBcIk5vIG1vZHVsZXMgZm91bmQgaW4gcHJvamVjdC5cIiB9KVxuICAgICAgfVxuICAgICAgZ2FyZGVuLmxvZy5pbmZvKHsgbXNnOiBcIkFib3J0aW5nLi4uXCIgfSlcbiAgICAgIHJldHVybiB7fVxuICAgIH1cblxuICAgIGNvbnN0IHRhc2tzRm9yTW9kdWxlID0gKHdhdGNoOiBib29sZWFuKSA9PiB7XG4gICAgICByZXR1cm4gYXN5bmMgKG1vZHVsZTogTW9kdWxlKSA9PiB7XG5cbiAgICAgICAgY29uc3QgdGVzdE1vZHVsZXM6IE1vZHVsZVtdID0gd2F0Y2hcbiAgICAgICAgICA/IChhd2FpdCB3aXRoRGVwZW5kYW50cyhnYXJkZW4sIFttb2R1bGVdLCBhdXRvUmVsb2FkRGVwZW5kYW50cykpXG4gICAgICAgICAgOiBbbW9kdWxlXVxuXG4gICAgICAgIGNvbnN0IHRlc3RUYXNrczogVGFza1tdID0gZmxhdHRlbihhd2FpdCBCbHVlYmlyZC5tYXAoXG4gICAgICAgICAgdGVzdE1vZHVsZXMsIG0gPT4gZ2V0VGVzdFRhc2tzKHsgZ2FyZGVuLCBtb2R1bGU6IG0gfSkpKVxuXG4gICAgICAgIGNvbnN0IGRlcGxveVRhc2tzID0gYXdhaXQgZ2V0RGVwbG95VGFza3Moe1xuICAgICAgICAgIGdhcmRlbiwgbW9kdWxlLCBmb3JjZTogd2F0Y2gsIGZvcmNlQnVpbGQ6IHdhdGNoLCBpbmNsdWRlRGVwZW5kYW50czogd2F0Y2gsXG4gICAgICAgIH0pXG4gICAgICAgIGNvbnN0IHRhc2tzID0gdGVzdFRhc2tzLmNvbmNhdChkZXBsb3lUYXNrcylcblxuICAgICAgICBpZiAodGFza3MubGVuZ3RoID09PSAwKSB7XG4gICAgICAgICAgcmV0dXJuIFtuZXcgQnVpbGRUYXNrKHsgZ2FyZGVuLCBtb2R1bGUsIGZvcmNlOiB3YXRjaCB9KV1cbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICByZXR1cm4gdGFza3NcbiAgICAgICAgfVxuICAgICAgfVxuXG4gICAgfVxuXG4gICAgYXdhaXQgcHJvY2Vzc01vZHVsZXMoe1xuICAgICAgZ2FyZGVuLFxuICAgICAgbW9kdWxlcyxcbiAgICAgIHdhdGNoOiB0cnVlLFxuICAgICAgaGFuZGxlcjogdGFza3NGb3JNb2R1bGUoZmFsc2UpLFxuICAgICAgY2hhbmdlSGFuZGxlcjogdGFza3NGb3JNb2R1bGUodHJ1ZSksXG4gICAgfSlcblxuICAgIHJldHVybiB7fVxuICB9XG59XG5cbmZ1bmN0aW9uIGdldEdyZWV0aW5nVGltZSgpIHtcbiAgY29uc3QgbSA9IG1vbWVudCgpXG5cbiAgY29uc3QgY3VycmVudEhvdXIgPSBwYXJzZUZsb2F0KG0uZm9ybWF0KFwiSEhcIikpXG5cbiAgaWYgKGN1cnJlbnRIb3VyID49IDE3KSB7XG4gICAgcmV0dXJuIFwiZXZlbmluZ1wiXG4gIH0gZWxzZSBpZiAoY3VycmVudEhvdXIgPj0gMTIpIHtcbiAgICByZXR1cm4gXCJhZnRlcm5vb25cIlxuICB9IGVsc2Uge1xuICAgIHJldHVybiBcIm1vcm5pbmdcIlxuICB9XG59XG4iXX0= diff --git a/garden-service/build/commands/exec.d.ts b/garden-service/build/commands/exec.d.ts new file mode 100644 index 00000000000..73afacb3cdc --- /dev/null +++ b/garden-service/build/commands/exec.d.ts @@ -0,0 +1,23 @@ +import { LoggerType } from "../logger/logger"; +import { ExecInServiceResult } from "../types/plugin/outputs"; +import { Command, CommandResult, CommandParams, StringParameter, StringsParameter } from "./base"; +declare const runArgs: { + service: StringParameter; + command: StringsParameter; +}; +declare type Args = typeof runArgs; +export declare class ExecCommand extends Command { + name: string; + alias: string; + help: string; + description: string; + arguments: { + service: StringParameter; + command: StringsParameter; + }; + options: {}; + loggerType: LoggerType; + action({ garden, args }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=exec.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/exec.js b/garden-service/build/commands/exec.js new file mode 100644 index 00000000000..7f4ae693c34 --- /dev/null +++ b/garden-service/build/commands/exec.js @@ -0,0 +1,74 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const chalk_1 = require("chalk"); +const logger_1 = require("../logger/logger"); +const base_1 = require("./base"); +const dedent = require("dedent"); +const runArgs = { + service: new base_1.StringParameter({ + help: "The service to exec the command in.", + required: true, + }), + command: new base_1.StringsParameter({ + help: "The command to run.", + required: true, + }), +}; +const runOpts = { +// interactive: new BooleanParameter({ +// help: "Set to false to skip interactive mode and just output the command result", +// defaultValue: true, +// }), +}; +class ExecCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "exec"; + this.alias = "e"; + this.help = "Executes a command (such as an interactive shell) in a running service."; + this.description = dedent ` + Finds an active container for a deployed service and executes the given command within the container. + Supports interactive shells. + + _NOTE: This command may not be supported for all module types._ + + Examples: + + garden exec my-service /bin/sh # runs a shell in the my-service container + `; + this.arguments = runArgs; + this.options = runOpts; + this.loggerType = logger_1.LoggerType.basic; + } + action({ garden, args }) { + return __awaiter(this, void 0, void 0, function* () { + const serviceName = args.service; + const command = args.command || []; + garden.log.header({ + emoji: "runner", + command: `Running command ${chalk_1.default.cyan(command.join(" "))} in service ${chalk_1.default.cyan(serviceName)}`, + }); + const service = yield garden.getService(serviceName); + const result = yield garden.actions.execInService({ service, command }); + return { result }; + }); + } +} +exports.ExecCommand = ExecCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/get.d.ts b/garden-service/build/commands/get.d.ts new file mode 100644 index 00000000000..99e845a6389 --- /dev/null +++ b/garden-service/build/commands/get.d.ts @@ -0,0 +1,30 @@ +import { Command, CommandResult, CommandParams, StringParameter } from "./base"; +import { ContextStatus } from "../actions"; +export declare class GetCommand extends Command { + name: string; + help: string; + subCommands: (typeof GetSecretCommand | typeof GetStatusCommand)[]; + action(): Promise<{}>; +} +declare const getSecretArgs: { + provider: StringParameter; + key: StringParameter; +}; +declare type GetArgs = typeof getSecretArgs; +export declare class GetSecretCommand extends Command { + name: string; + help: string; + description: string; + arguments: { + provider: StringParameter; + key: StringParameter; + }; + action({ garden, args }: CommandParams): Promise; +} +export declare class GetStatusCommand extends Command { + name: string; + help: string; + action({ garden }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=get.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/get.js b/garden-service/build/commands/get.js new file mode 100644 index 00000000000..755ce1befb6 --- /dev/null +++ b/garden-service/build/commands/get.js @@ -0,0 +1,95 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const yaml = require("js-yaml"); +const exceptions_1 = require("../exceptions"); +const util_1 = require("../util/util"); +const base_1 = require("./base"); +const dedent = require("dedent"); +class GetCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "get"; + this.help = "Retrieve and output data and objects, e.g. secrets, status info etc."; + this.subCommands = [ + GetSecretCommand, + GetStatusCommand, + ]; + } + action() { + return __awaiter(this, void 0, void 0, function* () { return {}; }); + } +} +exports.GetCommand = GetCommand; +const getSecretArgs = { + provider: new base_1.StringParameter({ + help: "The name of the provider to read the secret from.", + required: true, + }), + key: new base_1.StringParameter({ + help: "The key of the configuration variable.", + required: true, + }), +}; +// TODO: allow omitting key to return all configs +class GetSecretCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "secret"; + this.help = "Get a secret from the environment."; + this.description = dedent ` + Returns with an error if the provided key could not be found. + + Examples: + + garden get secret kubernetes somekey + garden get secret local-kubernetes some-other-key + `; + this.arguments = getSecretArgs; + } + action({ garden, args }) { + return __awaiter(this, void 0, void 0, function* () { + const key = args.key; + const { value } = yield garden.actions.getSecret({ pluginName: args.provider, key }); + if (value === null || value === undefined) { + throw new exceptions_1.NotFoundError(`Could not find config key ${key}`, { key }); + } + garden.log.info(value); + return { [key]: value }; + }); + } +} +exports.GetSecretCommand = GetSecretCommand; +class GetStatusCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "status"; + this.help = "Outputs the status of your environment."; + } + action({ garden }) { + return __awaiter(this, void 0, void 0, function* () { + const status = yield garden.actions.getStatus(); + const yamlStatus = yaml.safeDump(status, { noRefs: true, skipInvalid: true }); + // TODO: do a nicer print of this by default and add --yaml/--json options (maybe globally) for exporting + garden.log.info(util_1.highlightYaml(yamlStatus)); + return { result: status }; + }); + } +} +exports.GetStatusCommand = GetStatusCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/init.d.ts b/garden-service/build/commands/init.d.ts new file mode 100644 index 00000000000..b4072fb01c0 --- /dev/null +++ b/garden-service/build/commands/init.d.ts @@ -0,0 +1,16 @@ +import { BooleanParameter, Command, CommandResult, CommandParams } from "./base"; +declare const initOpts: { + force: BooleanParameter; +}; +declare type Opts = typeof initOpts; +export declare class InitCommand extends Command { + name: string; + help: string; + description: string; + options: { + force: BooleanParameter; + }; + action({ garden, opts }: CommandParams<{}, Opts>): Promise>; +} +export {}; +//# sourceMappingURL=init.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/init.js b/garden-service/build/commands/init.js new file mode 100644 index 00000000000..9dc68dd3f59 --- /dev/null +++ b/garden-service/build/commands/init.js @@ -0,0 +1,52 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("./base"); +const dedent = require("dedent"); +const initOpts = { + force: new base_1.BooleanParameter({ help: "Force initalization of environment, ignoring the environment status check." }), +}; +class InitCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "init"; + this.help = "Initialize system, environment or other runtime components."; + this.description = dedent ` + This command needs to be run before first deploying a Garden project, and occasionally after updating Garden, + plugins or project configuration. + + Examples: + + garden init + garden init --force # runs the init flows even if status checks report that the environment is ready + `; + this.options = initOpts; + } + action({ garden, opts }) { + return __awaiter(this, void 0, void 0, function* () { + const { name } = garden.environment; + garden.log.header({ emoji: "gear", command: `Initializing ${name} environment` }); + yield garden.actions.prepareEnvironment({ force: opts.force, allowUserInput: true }); + garden.log.info(""); + garden.log.header({ emoji: "heavy_check_mark", command: `Done!` }); + return { result: {} }; + }); + } +} +exports.InitCommand = InitCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/link/link.d.ts b/garden-service/build/commands/link/link.d.ts new file mode 100644 index 00000000000..566ee5ec305 --- /dev/null +++ b/garden-service/build/commands/link/link.d.ts @@ -0,0 +1,10 @@ +import { Command } from "../base"; +import { LinkSourceCommand } from "./source"; +import { LinkModuleCommand } from "./module"; +export declare class LinkCommand extends Command { + name: string; + help: string; + subCommands: (typeof LinkSourceCommand | typeof LinkModuleCommand)[]; + action(): Promise<{}>; +} +//# sourceMappingURL=link.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/link/link.js b/garden-service/build/commands/link/link.js new file mode 100644 index 00000000000..6e7cbffd171 --- /dev/null +++ b/garden-service/build/commands/link/link.js @@ -0,0 +1,37 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("../base"); +const source_1 = require("./source"); +const module_1 = require("./module"); +class LinkCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "link"; + this.help = "Link a remote source or module to a local path"; + this.subCommands = [ + source_1.LinkSourceCommand, + module_1.LinkModuleCommand, + ]; + } + action() { + return __awaiter(this, void 0, void 0, function* () { return {}; }); + } +} +exports.LinkCommand = LinkCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbW1hbmRzL2xpbmsvbGluay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7O0FBRUgsa0NBQWlDO0FBQ2pDLHFDQUE0QztBQUM1QyxxQ0FBNEM7QUFFNUMsTUFBYSxXQUFZLFNBQVEsY0FBTztJQUF4Qzs7UUFDRSxTQUFJLEdBQUcsTUFBTSxDQUFBO1FBQ2IsU0FBSSxHQUFHLGdEQUFnRCxDQUFBO1FBRXZELGdCQUFXLEdBQUc7WUFDWiwwQkFBaUI7WUFDakIsMEJBQWlCO1NBQ2xCLENBQUE7SUFHSCxDQUFDO0lBRE8sTUFBTTs4REFBSyxPQUFPLEVBQUUsQ0FBQSxDQUFDLENBQUM7S0FBQTtDQUM3QjtBQVZELGtDQVVDIiwiZmlsZSI6ImNvbW1hbmRzL2xpbmsvbGluay5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKEMpIDIwMTggR2FyZGVuIFRlY2hub2xvZ2llcywgSW5jLiA8aW5mb0BnYXJkZW4uaW8+XG4gKlxuICogVGhpcyBTb3VyY2UgQ29kZSBGb3JtIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoZSBNb3ppbGxhIFB1YmxpY1xuICogTGljZW5zZSwgdi4gMi4wLiBJZiBhIGNvcHkgb2YgdGhlIE1QTCB3YXMgbm90IGRpc3RyaWJ1dGVkIHdpdGggdGhpc1xuICogZmlsZSwgWW91IGNhbiBvYnRhaW4gb25lIGF0IGh0dHA6Ly9tb3ppbGxhLm9yZy9NUEwvMi4wLy5cbiAqL1xuXG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcIi4uL2Jhc2VcIlxuaW1wb3J0IHsgTGlua1NvdXJjZUNvbW1hbmQgfSBmcm9tIFwiLi9zb3VyY2VcIlxuaW1wb3J0IHsgTGlua01vZHVsZUNvbW1hbmQgfSBmcm9tIFwiLi9tb2R1bGVcIlxuXG5leHBvcnQgY2xhc3MgTGlua0NvbW1hbmQgZXh0ZW5kcyBDb21tYW5kIHtcbiAgbmFtZSA9IFwibGlua1wiXG4gIGhlbHAgPSBcIkxpbmsgYSByZW1vdGUgc291cmNlIG9yIG1vZHVsZSB0byBhIGxvY2FsIHBhdGhcIlxuXG4gIHN1YkNvbW1hbmRzID0gW1xuICAgIExpbmtTb3VyY2VDb21tYW5kLFxuICAgIExpbmtNb2R1bGVDb21tYW5kLFxuICBdXG5cbiAgYXN5bmMgYWN0aW9uKCkgeyByZXR1cm4ge30gfVxufVxuIl19 diff --git a/garden-service/build/commands/link/module.d.ts b/garden-service/build/commands/link/module.d.ts new file mode 100644 index 00000000000..bcf442b9f16 --- /dev/null +++ b/garden-service/build/commands/link/module.d.ts @@ -0,0 +1,19 @@ +import { Command, CommandResult, StringParameter, PathParameter, CommandParams } from "../base"; +import { LinkedSource } from "../../config-store"; +declare const linkModuleArguments: { + module: StringParameter; + path: PathParameter; +}; +declare type Args = typeof linkModuleArguments; +export declare class LinkModuleCommand extends Command { + name: string; + help: string; + arguments: { + module: StringParameter; + path: PathParameter; + }; + description: string; + action({ garden, args }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=module.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/link/module.js b/garden-service/build/commands/link/module.js new file mode 100644 index 00000000000..5b04f010d6f --- /dev/null +++ b/garden-service/build/commands/link/module.js @@ -0,0 +1,78 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const dedent = require("dedent"); +const chalk_1 = require("chalk"); +const exceptions_1 = require("../../exceptions"); +const base_1 = require("../base"); +const ext_source_util_1 = require("../../util/ext-source-util"); +const linkModuleArguments = { + module: new base_1.StringParameter({ + help: "Name of the module to link.", + required: true, + }), + path: new base_1.PathParameter({ + help: "Path to the local directory that containes the module.", + required: true, + }), +}; +class LinkModuleCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "module"; + this.help = "Link a module to a local directory."; + this.arguments = linkModuleArguments; + this.description = dedent ` + After linking a remote module, Garden will read the source from the module's local directory instead of from + the remote URL. Garden can only link modules that have a remote source, + i.e. modules that specifiy a repositoryUrl in their garden.yml config file. + + Examples: + + garden link module my-module path/to/my-module # links my-module to its local version at the given path + `; + } + action({ garden, args }) { + return __awaiter(this, void 0, void 0, function* () { + garden.log.header({ emoji: "link", command: "link module" }); + const sourceType = "module"; + const { module: moduleName, path } = args; + const moduleToLink = yield garden.getModule(moduleName); + const isRemote = [moduleToLink].filter(ext_source_util_1.hasRemoteSource)[0]; + if (!isRemote) { + const modulesWithRemoteSource = (yield garden.getModules()).filter(ext_source_util_1.hasRemoteSource).sort(); + throw new exceptions_1.ParameterError(`Expected module(s) ${chalk_1.default.underline(moduleName)} to have a remote source.` + + ` Did you mean to use the "link source" command?`, { + modulesWithRemoteSource, + input: module, + }); + } + const absPath = path_1.resolve(garden.projectRoot, path); + const linkedModuleSources = yield ext_source_util_1.addLinkedSources({ + garden, + sourceType, + sources: [{ name: moduleName, path: absPath }], + }); + garden.log.info(`Linked module ${moduleName}`); + return { result: linkedModuleSources }; + }); + } +} +exports.LinkModuleCommand = LinkModuleCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/link/source.d.ts b/garden-service/build/commands/link/source.d.ts new file mode 100644 index 00000000000..d236c1a7cd6 --- /dev/null +++ b/garden-service/build/commands/link/source.d.ts @@ -0,0 +1,20 @@ +import { Command, CommandResult, StringParameter, PathParameter } from "../base"; +import { LinkedSource } from "../../config-store"; +import { CommandParams } from "../base"; +declare const linkSourceArguments: { + source: StringParameter; + path: PathParameter; +}; +declare type Args = typeof linkSourceArguments; +export declare class LinkSourceCommand extends Command { + name: string; + help: string; + arguments: { + source: StringParameter; + path: PathParameter; + }; + description: string; + action({ garden, args }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=source.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/link/source.js b/garden-service/build/commands/link/source.js new file mode 100644 index 00000000000..3f977c768b9 --- /dev/null +++ b/garden-service/build/commands/link/source.js @@ -0,0 +1,77 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const dedent = require("dedent"); +const chalk_1 = require("chalk"); +const exceptions_1 = require("../../exceptions"); +const base_1 = require("../base"); +const ext_source_util_1 = require("../../util/ext-source-util"); +const linkSourceArguments = { + source: new base_1.StringParameter({ + help: "Name of the source to link as declared in the project config.", + required: true, + }), + path: new base_1.PathParameter({ + help: "Path to the local directory that containes the source.", + required: true, + }), +}; +class LinkSourceCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "source"; + this.help = "Link a remote source to a local directory."; + this.arguments = linkSourceArguments; + this.description = dedent ` + After linking a remote source, Garden will read it from its local directory instead of + from the remote URL. Garden can only link remote sources that have been declared in the project + level garden.yml config. + + Examples: + + garden link source my-source path/to/my-source # links my-source to its local version at the given path + `; + } + action({ garden, args }) { + return __awaiter(this, void 0, void 0, function* () { + garden.log.header({ emoji: "link", command: "link source" }); + const sourceType = "project"; + const { source: sourceName, path } = args; + const projectSourceToLink = garden.projectSources.find(src => src.name === sourceName); + if (!projectSourceToLink) { + const availableRemoteSources = garden.projectSources.map(s => s.name).sort(); + throw new exceptions_1.ParameterError(`Remote source ${chalk_1.default.underline(sourceName)} not found in project config.` + + ` Did you mean to use the "link module" command?`, { + availableRemoteSources, + input: sourceName, + }); + } + const absPath = path_1.resolve(garden.projectRoot, path); + const linkedProjectSources = yield ext_source_util_1.addLinkedSources({ + garden, + sourceType, + sources: [{ name: sourceName, path: absPath }], + }); + garden.log.info(`Linked source ${sourceName}`); + return { result: linkedProjectSources }; + }); + } +} +exports.LinkSourceCommand = LinkSourceCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/logs.d.ts b/garden-service/build/commands/logs.d.ts new file mode 100644 index 00000000000..25751a86fee --- /dev/null +++ b/garden-service/build/commands/logs.d.ts @@ -0,0 +1,26 @@ +import { BooleanParameter, Command, CommandResult, CommandParams, StringsParameter } from "./base"; +import { ServiceLogEntry } from "../types/plugin/outputs"; +import { LoggerType } from "../logger/logger"; +declare const logsArgs: { + service: StringsParameter; +}; +declare const logsOpts: { + tail: BooleanParameter; +}; +declare type Args = typeof logsArgs; +declare type Opts = typeof logsOpts; +export declare class LogsCommand extends Command { + name: string; + help: string; + description: string; + arguments: { + service: StringsParameter; + }; + options: { + tail: BooleanParameter; + }; + loggerType: LoggerType; + action({ garden, args, opts }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=logs.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/logs.js b/garden-service/build/commands/logs.js new file mode 100644 index 00000000000..bbd42ece155 --- /dev/null +++ b/garden-service/build/commands/logs.js @@ -0,0 +1,87 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("./base"); +const chalk_1 = require("chalk"); +const Bluebird = require("bluebird"); +const ts_stream_1 = require("ts-stream"); +const logger_1 = require("../logger/logger"); +const dedent = require("dedent"); +const logsArgs = { + service: new base_1.StringsParameter({ + help: "The name of the service(s) to logs (skip to logs all services). " + + "Use comma as separator to specify multiple services.", + }), +}; +const logsOpts = { + tail: new base_1.BooleanParameter({ help: "Continuously stream new logs from the service(s).", alias: "t" }), +}; +class LogsCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "logs"; + this.help = "Retrieves the most recent logs for the specified service(s)."; + this.description = dedent ` + Outputs logs for all or specified services, and optionally waits for news logs to come in. + + Examples: + + garden logs # prints latest logs from all services + garden logs my-service # prints latest logs for my-service + garden logs -t # keeps running and streams all incoming logs to the console + `; + this.arguments = logsArgs; + this.options = logsOpts; + this.loggerType = logger_1.LoggerType.basic; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + const tail = opts.tail; + const services = yield garden.getServices(args.service); + const result = []; + const stream = new ts_stream_1.default(); + // TODO: use basic logger (no need for fancy stuff here, just causes flickering) + void stream.forEach((entry) => { + // TODO: color each service differently for easier visual parsing + let timestamp = " "; + // bad timestamp values can cause crash if not caught + if (entry.timestamp) { + try { + timestamp = entry.timestamp.toISOString(); + } + catch (_a) { } + } + garden.log.info({ + section: entry.serviceName, + msg: [timestamp, chalk_1.default.white(entry.msg)], + }); + if (!tail) { + result.push(entry); + } + }); + // NOTE: This will work differently when we have Elasticsearch set up for logging, but is + // quite servicable for now. + yield Bluebird.map(services, (service) => __awaiter(this, void 0, void 0, function* () { + yield garden.actions.getServiceLogs({ service, stream, tail }); + })); + return { result }; + }); + } +} +exports.LogsCommand = LogsCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/publish.d.ts b/garden-service/build/commands/publish.d.ts new file mode 100644 index 00000000000..1e360cc3fb5 --- /dev/null +++ b/garden-service/build/commands/publish.d.ts @@ -0,0 +1,29 @@ +import { BooleanParameter, Command, CommandParams, CommandResult, StringsParameter } from "./base"; +import { Module } from "../types/module"; +import { TaskResults } from "../task-graph"; +import { Garden } from "../garden"; +declare const publishArgs: { + module: StringsParameter; +}; +declare const publishOpts: { + "force-build": BooleanParameter; + "allow-dirty": BooleanParameter; +}; +declare type Args = typeof publishArgs; +declare type Opts = typeof publishOpts; +export declare class PublishCommand extends Command { + name: string; + help: string; + description: string; + arguments: { + module: StringsParameter; + }; + options: { + "force-build": BooleanParameter; + "allow-dirty": BooleanParameter; + }; + action({ garden, args, opts }: CommandParams): Promise>; +} +export declare function publishModules(garden: Garden, modules: Module[], forceBuild: boolean, allowDirty: boolean): Promise; +export {}; +//# sourceMappingURL=publish.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/publish.js b/garden-service/build/commands/publish.js new file mode 100644 index 00000000000..f0793a7d5ab --- /dev/null +++ b/garden-service/build/commands/publish.js @@ -0,0 +1,81 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("./base"); +const publish_1 = require("../tasks/publish"); +const exceptions_1 = require("../exceptions"); +const dedent = require("dedent"); +const publishArgs = { + module: new base_1.StringsParameter({ + help: "The name of the module(s) to publish (skip to publish all modules). " + + "Use comma as separator to specify multiple modules.", + }), +}; +const publishOpts = { + "force-build": new base_1.BooleanParameter({ + help: "Force rebuild of module(s) before publishing.", + }), + "allow-dirty": new base_1.BooleanParameter({ + help: "Allow publishing dirty builds (with untracked/uncommitted changes).", + }), +}; +class PublishCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "publish"; + this.help = "Build and publish module(s) to a remote registry."; + this.description = dedent ` + Publishes built module artifacts for all or specified modules. + Also builds modules and dependencies if needed. + + Examples: + + garden publish # publish artifacts for all modules in the project + garden publish my-container # only publish my-container + garden publish --force-build # force re-build of modules before publishing artifacts + garden publish --allow-dirty # allow publishing dirty builds (which by default triggers error) + `; + this.arguments = publishArgs; + this.options = publishOpts; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + garden.log.header({ emoji: "rocket", command: "Publish modules" }); + const modules = yield garden.getModules(args.module); + const results = yield publishModules(garden, modules, !!opts["force-build"], !!opts["allow-dirty"]); + return base_1.handleTaskResults(garden, "publish", { taskResults: results }); + }); + } +} +exports.PublishCommand = PublishCommand; +function publishModules(garden, modules, forceBuild, allowDirty) { + return __awaiter(this, void 0, void 0, function* () { + for (const module of modules) { + const version = module.version; + if (version.dirtyTimestamp && !allowDirty) { + throw new exceptions_1.RuntimeError(`Module ${module.name} has uncommitted changes. ` + + `Please commit them, clean the module's source tree or set the --allow-dirty flag to override.`, { moduleName: module.name, version }); + } + const task = new publish_1.PublishTask({ garden, module, forceBuild }); + yield garden.addTask(task); + } + return yield garden.processTasks(); + }); +} +exports.publishModules = publishModules; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/run/module.d.ts b/garden-service/build/commands/run/module.d.ts new file mode 100644 index 00000000000..427e2d0f3cc --- /dev/null +++ b/garden-service/build/commands/run/module.d.ts @@ -0,0 +1,29 @@ +import { RunResult } from "../../types/plugin/outputs"; +import { BooleanParameter, Command, CommandParams, StringParameter, CommandResult, StringsParameter } from "../base"; +declare const runArgs: { + module: StringParameter; + command: StringsParameter; +}; +declare const runOpts: { + interactive: BooleanParameter; + "force-build": BooleanParameter; +}; +declare type Args = typeof runArgs; +declare type Opts = typeof runOpts; +export declare class RunModuleCommand extends Command { + name: string; + alias: string; + help: string; + description: string; + arguments: { + module: StringParameter; + command: StringsParameter; + }; + options: { + interactive: BooleanParameter; + "force-build": BooleanParameter; + }; + action({ garden, args, opts }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=module.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/run/module.js b/garden-service/build/commands/run/module.js new file mode 100644 index 00000000000..ca0cae47cbe --- /dev/null +++ b/garden-service/build/commands/run/module.js @@ -0,0 +1,97 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const chalk_1 = require("chalk"); +const build_1 = require("../../tasks/build"); +const base_1 = require("../base"); +const lodash_1 = require("lodash"); +const run_1 = require("./run"); +const dedent = require("dedent"); +const service_1 = require("../../types/service"); +const runArgs = { + module: new base_1.StringParameter({ + help: "The name of the module to run.", + required: true, + }), + // TODO: make this a variadic arg + command: new base_1.StringsParameter({ + help: "The command to run in the module.", + }), +}; +const runOpts = { + // TODO: we could provide specific parameters like this by adding commands for specific modules, via plugins + //entrypoint: new StringParameter({ help: "Override default entrypoint in module" }), + interactive: new base_1.BooleanParameter({ + help: "Set to false to skip interactive mode and just output the command result.", + defaultValue: true, + }), + "force-build": new base_1.BooleanParameter({ help: "Force rebuild of module before running." }), +}; +class RunModuleCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "module"; + this.alias = "m"; + this.help = "Run an ad-hoc instance of a module."; + this.description = dedent ` + This is useful for debugging or ad-hoc experimentation with modules. + + Examples: + + garden run module my-container # run an ad-hoc instance of a my-container container and attach to it + garden run module my-container /bin/sh # run an interactive shell in a new my-container container + garden run module my-container --i=false /some/script # execute a script in my-container and return the output + `; + this.arguments = runArgs; + this.options = runOpts; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + const moduleName = args.module; + const module = yield garden.getModule(moduleName); + const msg = args.command + ? `Running command ${chalk_1.default.white(args.command.join(" "))} in module ${chalk_1.default.white(moduleName)}` + : `Running module ${chalk_1.default.white(moduleName)}`; + garden.log.header({ + emoji: "runner", + command: msg, + }); + yield garden.actions.prepareEnvironment({}); + const buildTask = new build_1.BuildTask({ garden, module, force: opts["force-build"] }); + yield garden.addTask(buildTask); + yield garden.processTasks(); + const command = args.command || []; + // combine all dependencies for all services in the module, to be sure we have all the context we need + const depNames = lodash_1.uniq(lodash_1.flatten(module.serviceConfigs.map(s => s.dependencies))); + const deps = yield garden.getServices(depNames); + const runtimeContext = yield service_1.prepareRuntimeContext(garden, module, deps); + run_1.printRuntimeContext(garden, runtimeContext); + garden.log.info(""); + const result = yield garden.actions.runModule({ + module, + command, + runtimeContext, + silent: false, + interactive: opts.interactive, + }); + return { result }; + }); + } +} +exports.RunModuleCommand = RunModuleCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/run/run.d.ts b/garden-service/build/commands/run/run.d.ts new file mode 100644 index 00000000000..2b6b62bdd21 --- /dev/null +++ b/garden-service/build/commands/run/run.d.ts @@ -0,0 +1,15 @@ +import { RuntimeContext } from "../../types/service"; +import { Command } from "../base"; +import { RunModuleCommand } from "./module"; +import { RunServiceCommand } from "./service"; +import { RunTestCommand } from "./test"; +import { Garden } from "../../garden"; +export declare class RunCommand extends Command { + name: string; + alias: string; + help: string; + subCommands: (typeof RunModuleCommand | typeof RunServiceCommand | typeof RunTestCommand)[]; + action(): Promise<{}>; +} +export declare function printRuntimeContext(garden: Garden, runtimeContext: RuntimeContext): void; +//# sourceMappingURL=run.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/run/run.js b/garden-service/build/commands/run/run.js new file mode 100644 index 00000000000..6e0307f6c8b --- /dev/null +++ b/garden-service/build/commands/run/run.js @@ -0,0 +1,51 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const js_yaml_1 = require("js-yaml"); +const util_1 = require("../../util/util"); +const base_1 = require("../base"); +const module_1 = require("./module"); +const service_1 = require("./service"); +const test_1 = require("./test"); +class RunCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "run"; + this.alias = "r"; + this.help = "Run ad-hoc instances of your modules, services and tests"; + this.subCommands = [ + module_1.RunModuleCommand, + service_1.RunServiceCommand, + test_1.RunTestCommand, + ]; + } + action() { + return __awaiter(this, void 0, void 0, function* () { return {}; }); + } +} +exports.RunCommand = RunCommand; +function printRuntimeContext(garden, runtimeContext) { + garden.log.verbose("-----------------------------------\n"); + garden.log.verbose("Environment variables:"); + garden.log.verbose(util_1.highlightYaml(js_yaml_1.safeDump(runtimeContext.envVars))); + garden.log.verbose("Dependencies:"); + garden.log.verbose(util_1.highlightYaml(js_yaml_1.safeDump(runtimeContext.dependencies))); + garden.log.verbose("-----------------------------------\n"); +} +exports.printRuntimeContext = printRuntimeContext; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/run/service.d.ts b/garden-service/build/commands/run/service.d.ts new file mode 100644 index 00000000000..6858913a3db --- /dev/null +++ b/garden-service/build/commands/run/service.d.ts @@ -0,0 +1,25 @@ +import { RunResult } from "../../types/plugin/outputs"; +import { BooleanParameter, Command, CommandParams, CommandResult, StringParameter } from "../base"; +declare const runArgs: { + service: StringParameter; +}; +declare const runOpts: { + "force-build": BooleanParameter; +}; +declare type Args = typeof runArgs; +declare type Opts = typeof runOpts; +export declare class RunServiceCommand extends Command { + name: string; + alias: string; + help: string; + description: string; + arguments: { + service: StringParameter; + }; + options: { + "force-build": BooleanParameter; + }; + action({ garden, args, opts }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=service.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/run/service.js b/garden-service/build/commands/run/service.js new file mode 100644 index 00000000000..85c51a9ab45 --- /dev/null +++ b/garden-service/build/commands/run/service.js @@ -0,0 +1,72 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const chalk_1 = require("chalk"); +const build_1 = require("../../tasks/build"); +const base_1 = require("../base"); +const run_1 = require("./run"); +const dedent = require("dedent"); +const service_1 = require("../../types/service"); +const runArgs = { + service: new base_1.StringParameter({ + help: "The service to run", + required: true, + }), +}; +const runOpts = { + "force-build": new base_1.BooleanParameter({ help: "Force rebuild of module" }), +}; +class RunServiceCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "service"; + this.alias = "s"; + this.help = "Run an ad-hoc instance of the specified service"; + this.description = dedent ` + This can be useful for debugging or ad-hoc experimentation with services. + + Examples: + + garden run service my-service # run an ad-hoc instance of a my-service and attach to it + `; + this.arguments = runArgs; + this.options = runOpts; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + const serviceName = args.service; + const service = yield garden.getService(serviceName); + const module = service.module; + garden.log.header({ + emoji: "runner", + command: `Running service ${chalk_1.default.cyan(serviceName)} in module ${chalk_1.default.cyan(module.name)}`, + }); + yield garden.actions.prepareEnvironment({}); + const buildTask = new build_1.BuildTask({ garden, module, force: opts["force-build"] }); + yield garden.addTask(buildTask); + yield garden.processTasks(); + const dependencies = yield garden.getServices(module.serviceDependencyNames); + const runtimeContext = yield service_1.prepareRuntimeContext(garden, module, dependencies); + run_1.printRuntimeContext(garden, runtimeContext); + const result = yield garden.actions.runService({ service, runtimeContext, silent: false, interactive: true }); + return { result }; + }); + } +} +exports.RunServiceCommand = RunServiceCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/run/test.d.ts b/garden-service/build/commands/run/test.d.ts new file mode 100644 index 00000000000..50d309f237b --- /dev/null +++ b/garden-service/build/commands/run/test.d.ts @@ -0,0 +1,29 @@ +import { RunResult } from "../../types/plugin/outputs"; +import { BooleanParameter, Command, CommandParams, CommandResult, StringParameter } from "../base"; +declare const runArgs: { + module: StringParameter; + test: StringParameter; +}; +declare const runOpts: { + interactive: BooleanParameter; + "force-build": BooleanParameter; +}; +declare type Args = typeof runArgs; +declare type Opts = typeof runOpts; +export declare class RunTestCommand extends Command { + name: string; + alias: string; + help: string; + description: string; + arguments: { + module: StringParameter; + test: StringParameter; + }; + options: { + interactive: BooleanParameter; + "force-build": BooleanParameter; + }; + action({ garden, args, opts }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=test.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/run/test.js b/garden-service/build/commands/run/test.js new file mode 100644 index 00000000000..5c6e8dfe74d --- /dev/null +++ b/garden-service/build/commands/run/test.js @@ -0,0 +1,98 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const chalk_1 = require("chalk"); +const exceptions_1 = require("../../exceptions"); +const build_1 = require("../../tasks/build"); +const util_1 = require("../../util/util"); +const base_1 = require("../base"); +const run_1 = require("./run"); +const dedent = require("dedent"); +const service_1 = require("../../types/service"); +const runArgs = { + module: new base_1.StringParameter({ + help: "The name of the module to run.", + required: true, + }), + test: new base_1.StringParameter({ + help: "The name of the test to run in the module.", + required: true, + }), +}; +const runOpts = { + interactive: new base_1.BooleanParameter({ + help: "Set to false to skip interactive mode and just output the command result.", + defaultValue: true, + }), + "force-build": new base_1.BooleanParameter({ help: "Force rebuild of module before running." }), +}; +class RunTestCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "test"; + this.alias = "t"; + this.help = "Run the specified module test."; + this.description = dedent ` + This can be useful for debugging tests, particularly integration/end-to-end tests. + + Examples: + + garden run test my-module integ # run the test named 'integ' in my-module + garden run test my-module integ --i=false # do not attach to the test run, just output results when completed + `; + this.arguments = runArgs; + this.options = runOpts; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + const moduleName = args.module; + const testName = args.test; + const module = yield garden.getModule(moduleName); + const testConfig = util_1.findByName(module.testConfigs, testName); + if (!testConfig) { + throw new exceptions_1.ParameterError(`Could not find test "${testName}" in module ${moduleName}`, { + moduleName, + testName, + availableTests: util_1.getNames(module.testConfigs), + }); + } + garden.log.header({ + emoji: "runner", + command: `Running test ${chalk_1.default.cyan(testName)} in module ${chalk_1.default.cyan(moduleName)}`, + }); + yield garden.actions.prepareEnvironment({}); + const buildTask = new build_1.BuildTask({ garden, module, force: opts["force-build"] }); + yield garden.addTask(buildTask); + yield garden.processTasks(); + const interactive = opts.interactive; + const deps = yield garden.getServices(testConfig.dependencies); + const runtimeContext = yield service_1.prepareRuntimeContext(garden, module, deps); + run_1.printRuntimeContext(garden, runtimeContext); + const result = yield garden.actions.testModule({ + module, + interactive, + runtimeContext, + silent: false, + testConfig, + }); + return { result }; + }); + } +} +exports.RunTestCommand = RunTestCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/scan.d.ts b/garden-service/build/commands/scan.d.ts new file mode 100644 index 00000000000..ab19af30eaa --- /dev/null +++ b/garden-service/build/commands/scan.d.ts @@ -0,0 +1,8 @@ +import { DeepPrimitiveMap } from "../config/common"; +import { Command, CommandParams, CommandResult } from "./base"; +export declare class ScanCommand extends Command { + name: string; + help: string; + action({ garden }: CommandParams): Promise>; +} +//# sourceMappingURL=scan.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/scan.js b/garden-service/build/commands/scan.js new file mode 100644 index 00000000000..0745a5ecbb6 --- /dev/null +++ b/garden-service/build/commands/scan.js @@ -0,0 +1,49 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const js_yaml_1 = require("js-yaml"); +const util_1 = require("../util/util"); +const base_1 = require("./base"); +const lodash_1 = require("lodash"); +class ScanCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "scan"; + this.help = "Scans your project and outputs an overview of all modules."; + } + action({ garden }) { + return __awaiter(this, void 0, void 0, function* () { + const modules = (yield garden.getModules()) + .map(m => { + m.services.forEach(s => delete s.module); + return lodash_1.omit(m, ["_ConfigType", "cacheContext", "serviceConfigs", "serviceNames"]); + }); + const output = { modules }; + const shortOutput = { + modules: modules.map(m => { + m.services.map(s => delete s.spec); + return lodash_1.omit(m, ["spec"]); + }), + }; + garden.log.info(util_1.highlightYaml(js_yaml_1.safeDump(shortOutput, { noRefs: true, skipInvalid: true, sortKeys: true }))); + return { result: output }; + }); + } +} +exports.ScanCommand = ScanCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/set.d.ts b/garden-service/build/commands/set.d.ts new file mode 100644 index 00000000000..5869ad745b6 --- /dev/null +++ b/garden-service/build/commands/set.d.ts @@ -0,0 +1,27 @@ +import { SetSecretResult } from "../types/plugin/outputs"; +import { Command, CommandResult, CommandParams, StringParameter } from "./base"; +export declare class SetCommand extends Command { + name: string; + help: string; + subCommands: (typeof SetSecretCommand)[]; + action(): Promise<{}>; +} +declare const setSecretArgs: { + provider: StringParameter; + key: StringParameter; + value: StringParameter; +}; +declare type SetArgs = typeof setSecretArgs; +export declare class SetSecretCommand extends Command { + name: string; + help: string; + description: string; + arguments: { + provider: StringParameter; + key: StringParameter; + value: StringParameter; + }; + action({ garden, args }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=set.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/set.js b/garden-service/build/commands/set.js new file mode 100644 index 00000000000..8ac4de3fd9b --- /dev/null +++ b/garden-service/build/commands/set.js @@ -0,0 +1,79 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("./base"); +const dedent = require("dedent"); +class SetCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "set"; + this.help = "Set or modify data, e.g. secrets."; + this.subCommands = [ + SetSecretCommand, + ]; + } + action() { + return __awaiter(this, void 0, void 0, function* () { return {}; }); + } +} +exports.SetCommand = SetCommand; +const setSecretArgs = { + provider: new base_1.StringParameter({ + help: "The name of the provider to store the secret with.", + required: true, + }), + key: new base_1.StringParameter({ + help: "A unique identifier for the secret.", + required: true, + }), + value: new base_1.StringParameter({ + help: "The value of the secret.", + required: true, + }), +}; +// TODO: allow storing data from files +class SetSecretCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "secret"; + this.help = "Set a secret value for a provider in an environment."; + this.description = dedent ` + These secrets are handled by each provider, and may for example be exposed as environment + variables for services or mounted as files, depending on how the provider is implemented + and configured. + + _Note: The value is currently always stored as a string._ + + Examples: + + garden set secret kubernetes somekey myvalue + garden set secret local-kubernets somekey myvalue + `; + this.arguments = setSecretArgs; + } + action({ garden, args }) { + return __awaiter(this, void 0, void 0, function* () { + const key = args.key; + const result = yield garden.actions.setSecret({ pluginName: args.provider, key, value: args.value }); + garden.log.info(`Set config key ${args.key}`); + return { result }; + }); + } +} +exports.SetSecretCommand = SetSecretCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/test.d.ts b/garden-service/build/commands/test.d.ts new file mode 100644 index 00000000000..a69727ac4e4 --- /dev/null +++ b/garden-service/build/commands/test.d.ts @@ -0,0 +1,40 @@ +import { BooleanParameter, Command, CommandParams, CommandResult, StringOption, StringsParameter } from "./base"; +import { TaskResults } from "../task-graph"; +import { Module } from "../types/module"; +import { TestTask } from "../tasks/test"; +import { Garden } from "../garden"; +declare const testArgs: { + module: StringsParameter; +}; +declare const testOpts: { + name: StringOption; + force: BooleanParameter; + "force-build": BooleanParameter; + watch: BooleanParameter; +}; +declare type Args = typeof testArgs; +declare type Opts = typeof testOpts; +export declare class TestCommand extends Command { + name: string; + help: string; + description: string; + arguments: { + module: StringsParameter; + }; + options: { + name: StringOption; + force: BooleanParameter; + "force-build": BooleanParameter; + watch: BooleanParameter; + }; + action({ garden, args, opts }: CommandParams): Promise>; +} +export declare function getTestTasks({ garden, module, name, force, forceBuild }: { + garden: Garden; + module: Module; + name?: string; + force?: boolean; + forceBuild?: boolean; +}): Promise; +export {}; +//# sourceMappingURL=test.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/test.js b/garden-service/build/commands/test.js new file mode 100644 index 00000000000..97a65cbe7b7 --- /dev/null +++ b/garden-service/build/commands/test.js @@ -0,0 +1,116 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const lodash_1 = require("lodash"); +const base_1 = require("./base"); +const process_1 = require("../process"); +const test_1 = require("../tasks/test"); +const watch_1 = require("../watch"); +const testArgs = { + module: new base_1.StringsParameter({ + help: "The name of the module(s) to deploy (skip to test all modules). " + + "Use comma as separator to specify multiple modules.", + }), +}; +const testOpts = { + name: new base_1.StringOption({ + help: "Only run tests with the specfied name (e.g. unit or integ).", + alias: "n", + }), + force: new base_1.BooleanParameter({ help: "Force re-test of module(s).", alias: "f" }), + "force-build": new base_1.BooleanParameter({ help: "Force rebuild of module(s)." }), + watch: new base_1.BooleanParameter({ help: "Watch for changes in module(s) and auto-test.", alias: "w" }), +}; +class TestCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "test"; + this.help = "Test all or specified modules."; + this.description = ` + Runs all or specified tests defined in the project. Also builds modules and dependencies, + and deploy service dependencies if needed. + + Optionally stays running and automatically re-runs tests if their module source + (or their dependencies' sources) change. + + Examples: + + garden test # run all tests in the project + garden test my-module # run all tests in the my-module module + garden test -n integ # run all tests with the name 'integ' in the project + garden test --force # force tests to be re-run, even if they're already run successfully + garden test --watch # watch for changes to code + `; + this.arguments = testArgs; + this.options = testOpts; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + const autoReloadDependants = yield watch_1.computeAutoReloadDependants(garden); + let modules; + if (args.module) { + modules = yield watch_1.withDependants(garden, yield garden.getModules(args.module), autoReloadDependants); + } + else { + // All modules are included in this case, so there's no need to compute dependants. + modules = yield garden.getModules(); + } + garden.log.header({ + emoji: "thermometer", + command: `Running tests`, + }); + yield garden.actions.prepareEnvironment({}); + const name = opts.name; + const force = opts.force; + const forceBuild = opts["force-build"]; + const results = yield process_1.processModules({ + garden, + modules, + watch: opts.watch, + handler: (module) => __awaiter(this, void 0, void 0, function* () { return getTestTasks({ garden, module, name, force, forceBuild }); }), + changeHandler: (module) => __awaiter(this, void 0, void 0, function* () { + const modulesToProcess = yield watch_1.withDependants(garden, [module], autoReloadDependants); + return lodash_1.flatten(yield Bluebird.map(modulesToProcess, m => getTestTasks({ garden, module: m, name, force, forceBuild }))); + }), + }); + return base_1.handleTaskResults(garden, "test", results); + }); + } +} +exports.TestCommand = TestCommand; +function getTestTasks({ garden, module, name, force = false, forceBuild = false }) { + return __awaiter(this, void 0, void 0, function* () { + const tasks = []; + for (const test of module.testConfigs) { + if (name && test.name !== name) { + continue; + } + tasks.push(test_1.TestTask.factory({ + garden, + force, + forceBuild, + testConfig: test, + module, + })); + } + return Bluebird.all(tasks); + }); +} +exports.getTestTasks = getTestTasks; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["commands/test.ts"],"names":[],"mappings":"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","file":"commands/test.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Bluebird from \"bluebird\"\nimport { flatten } from \"lodash\"\nimport {\n  BooleanParameter,\n  Command,\n  CommandParams,\n  CommandResult,\n  handleTaskResults,\n  StringOption,\n  StringsParameter,\n} from \"./base\"\nimport { TaskResults } from \"../task-graph\"\nimport { processModules } from \"../process\"\nimport { Module } from \"../types/module\"\nimport { TestTask } from \"../tasks/test\"\nimport { computeAutoReloadDependants, withDependants } from \"../watch\"\nimport { Garden } from \"../garden\"\n\nconst testArgs = {\n  module: new StringsParameter({\n    help: \"The name of the module(s) to deploy (skip to test all modules). \" +\n      \"Use comma as separator to specify multiple modules.\",\n  }),\n}\n\nconst testOpts = {\n  name: new StringOption({\n    help: \"Only run tests with the specfied name (e.g. unit or integ).\",\n    alias: \"n\",\n  }),\n  force: new BooleanParameter({ help: \"Force re-test of module(s).\", alias: \"f\" }),\n  \"force-build\": new BooleanParameter({ help: \"Force rebuild of module(s).\" }),\n  watch: new BooleanParameter({ help: \"Watch for changes in module(s) and auto-test.\", alias: \"w\" }),\n}\n\ntype Args = typeof testArgs\ntype Opts = typeof testOpts\n\nexport class TestCommand extends Command<Args, Opts> {\n  name = \"test\"\n  help = \"Test all or specified modules.\"\n\n  description = `\n    Runs all or specified tests defined in the project. Also builds modules and dependencies,\n    and deploy service dependencies if needed.\n\n    Optionally stays running and automatically re-runs tests if their module source\n    (or their dependencies' sources) change.\n\n    Examples:\n\n        garden test              # run all tests in the project\n        garden test my-module    # run all tests in the my-module module\n        garden test -n integ     # run all tests with the name 'integ' in the project\n        garden test --force      # force tests to be re-run, even if they're already run successfully\n        garden test --watch      # watch for changes to code\n  `\n\n  arguments = testArgs\n  options = testOpts\n\n  async action({ garden, args, opts }: CommandParams<Args, Opts>): Promise<CommandResult<TaskResults>> {\n    const autoReloadDependants = await computeAutoReloadDependants(garden)\n    let modules: Module[]\n    if (args.module) {\n      modules = await withDependants(garden, await garden.getModules(args.module), autoReloadDependants)\n    } else {\n      // All modules are included in this case, so there's no need to compute dependants.\n      modules = await garden.getModules()\n    }\n\n    garden.log.header({\n      emoji: \"thermometer\",\n      command: `Running tests`,\n    })\n\n    await garden.actions.prepareEnvironment({})\n\n    const name = opts.name\n    const force = opts.force\n    const forceBuild = opts[\"force-build\"]\n\n    const results = await processModules({\n      garden,\n      modules,\n      watch: opts.watch,\n      handler: async (module) => getTestTasks({ garden, module, name, force, forceBuild }),\n      changeHandler: async (module) => {\n        const modulesToProcess = await withDependants(garden, [module], autoReloadDependants)\n        return flatten(await Bluebird.map(\n          modulesToProcess,\n          m => getTestTasks({ garden, module: m, name, force, forceBuild })))\n      },\n    })\n\n    return handleTaskResults(garden, \"test\", results)\n  }\n}\n\nexport async function getTestTasks(\n  { garden, module, name, force = false, forceBuild = false }:\n    { garden: Garden, module: Module, name?: string, force?: boolean, forceBuild?: boolean },\n) {\n  const tasks: Promise<TestTask>[] = []\n\n  for (const test of module.testConfigs) {\n    if (name && test.name !== name) {\n      continue\n    }\n    tasks.push(TestTask.factory({\n      garden,\n      force,\n      forceBuild,\n      testConfig: test,\n      module,\n    }))\n  }\n\n  return Bluebird.all(tasks)\n}\n"]} diff --git a/garden-service/build/commands/unlink/module.d.ts b/garden-service/build/commands/unlink/module.d.ts new file mode 100644 index 00000000000..1db71e2e0c4 --- /dev/null +++ b/garden-service/build/commands/unlink/module.d.ts @@ -0,0 +1,24 @@ +import { Command, CommandResult, StringsParameter, BooleanParameter, CommandParams } from "../base"; +import { LinkedSource } from "../../config-store"; +declare const unlinkModuleArguments: { + module: StringsParameter; +}; +declare const unlinkModuleOptions: { + all: BooleanParameter; +}; +declare type Args = typeof unlinkModuleArguments; +declare type Opts = typeof unlinkModuleOptions; +export declare class UnlinkModuleCommand extends Command { + name: string; + help: string; + arguments: { + module: StringsParameter; + }; + options: { + all: BooleanParameter; + }; + description: string; + action({ garden, args, opts }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=module.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/unlink/module.js b/garden-service/build/commands/unlink/module.js new file mode 100644 index 00000000000..f8ed03cf747 --- /dev/null +++ b/garden-service/build/commands/unlink/module.js @@ -0,0 +1,68 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const dedent = require("dedent"); +const base_1 = require("../base"); +const ext_source_util_1 = require("../../util/ext-source-util"); +const config_store_1 = require("../../config-store"); +const unlinkModuleArguments = { + module: new base_1.StringsParameter({ + help: "Name of the module(s) to unlink. Use comma separator to specify multiple modules.", + }), +}; +const unlinkModuleOptions = { + all: new base_1.BooleanParameter({ + help: "Unlink all modules.", + alias: "a", + }), +}; +class UnlinkModuleCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "module"; + this.help = "Unlink a previously linked remote module from its local directory."; + this.arguments = unlinkModuleArguments; + this.options = unlinkModuleOptions; + this.description = dedent ` + After unlinking a remote module, Garden will go back to reading the module's source from + its remote URL instead of its local directory. + + Examples: + + garden unlink module my-module # unlinks my-module + garden unlink module --all # unlink all modules + `; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + garden.log.header({ emoji: "chains", command: "unlink module" }); + const sourceType = "module"; + const { module = [] } = args; + if (opts.all) { + yield garden.localConfigStore.set([config_store_1.localConfigKeys.linkedModuleSources], []); + garden.log.info("Unlinked all modules"); + return { result: [] }; + } + const linkedModuleSources = yield ext_source_util_1.removeLinkedSources({ garden, sourceType, names: module }); + garden.log.info(`Unlinked module(s) ${module}`); + return { result: linkedModuleSources }; + }); + } +} +exports.UnlinkModuleCommand = UnlinkModuleCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/unlink/source.d.ts b/garden-service/build/commands/unlink/source.d.ts new file mode 100644 index 00000000000..5754eb7ef11 --- /dev/null +++ b/garden-service/build/commands/unlink/source.d.ts @@ -0,0 +1,24 @@ +import { Command, CommandResult, StringsParameter, BooleanParameter, CommandParams } from "../base"; +import { LinkedSource } from "../../config-store"; +declare const unlinkSourceArguments: { + source: StringsParameter; +}; +declare const unlinkSourceOptions: { + all: BooleanParameter; +}; +declare type Args = typeof unlinkSourceArguments; +declare type Opts = typeof unlinkSourceOptions; +export declare class UnlinkSourceCommand extends Command { + name: string; + help: string; + arguments: { + source: StringsParameter; + }; + options: { + all: BooleanParameter; + }; + description: string; + action({ garden, args, opts }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=source.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/unlink/source.js b/garden-service/build/commands/unlink/source.js new file mode 100644 index 00000000000..e28d7b0823e --- /dev/null +++ b/garden-service/build/commands/unlink/source.js @@ -0,0 +1,68 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const dedent = require("dedent"); +const base_1 = require("../base"); +const ext_source_util_1 = require("../../util/ext-source-util"); +const config_store_1 = require("../../config-store"); +const unlinkSourceArguments = { + source: new base_1.StringsParameter({ + help: "Name of the source(s) to unlink. Use comma separator to specify multiple sources.", + }), +}; +const unlinkSourceOptions = { + all: new base_1.BooleanParameter({ + help: "Unlink all sources.", + alias: "a", + }), +}; +class UnlinkSourceCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "source"; + this.help = "Unlink a previously linked remote source from its local directory."; + this.arguments = unlinkSourceArguments; + this.options = unlinkSourceOptions; + this.description = dedent ` + After unlinking a remote source, Garden will go back to reading it from its remote URL instead + of its local directory. + + Examples: + + garden unlink source my-source # unlinks my-source + garden unlink source --all # unlinks all sources + `; + } + action({ garden, args, opts }) { + return __awaiter(this, void 0, void 0, function* () { + garden.log.header({ emoji: "chains", command: "unlink source" }); + const sourceType = "project"; + const { source = [] } = args; + if (opts.all) { + yield garden.localConfigStore.set([config_store_1.localConfigKeys.linkedProjectSources], []); + garden.log.info("Unlinked all sources"); + return { result: [] }; + } + const linkedProjectSources = yield ext_source_util_1.removeLinkedSources({ garden, sourceType, names: source }); + garden.log.info(`Unlinked source(s) ${source}`); + return { result: linkedProjectSources }; + }); + } +} +exports.UnlinkSourceCommand = UnlinkSourceCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/unlink/unlink.d.ts b/garden-service/build/commands/unlink/unlink.d.ts new file mode 100644 index 00000000000..08d3d05b22a --- /dev/null +++ b/garden-service/build/commands/unlink/unlink.d.ts @@ -0,0 +1,10 @@ +import { Command } from "../base"; +import { UnlinkSourceCommand } from "./source"; +import { UnlinkModuleCommand } from "./module"; +export declare class UnlinkCommand extends Command { + name: string; + help: string; + subCommands: (typeof UnlinkSourceCommand | typeof UnlinkModuleCommand)[]; + action(): Promise<{}>; +} +//# sourceMappingURL=unlink.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/unlink/unlink.js b/garden-service/build/commands/unlink/unlink.js new file mode 100644 index 00000000000..600e4156b56 --- /dev/null +++ b/garden-service/build/commands/unlink/unlink.js @@ -0,0 +1,37 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("../base"); +const source_1 = require("./source"); +const module_1 = require("./module"); +class UnlinkCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "unlink"; + this.help = "Unlink a remote source or module from its local path"; + this.subCommands = [ + source_1.UnlinkSourceCommand, + module_1.UnlinkModuleCommand, + ]; + } + action() { + return __awaiter(this, void 0, void 0, function* () { return {}; }); + } +} +exports.UnlinkCommand = UnlinkCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbW1hbmRzL3VubGluay91bmxpbmsudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7OztBQUVILGtDQUFpQztBQUNqQyxxQ0FBOEM7QUFDOUMscUNBQThDO0FBRTlDLE1BQWEsYUFBYyxTQUFRLGNBQU87SUFBMUM7O1FBQ0UsU0FBSSxHQUFHLFFBQVEsQ0FBQTtRQUNmLFNBQUksR0FBRyxzREFBc0QsQ0FBQTtRQUU3RCxnQkFBVyxHQUFHO1lBQ1osNEJBQW1CO1lBQ25CLDRCQUFtQjtTQUNwQixDQUFBO0lBR0gsQ0FBQztJQURPLE1BQU07OERBQUssT0FBTyxFQUFFLENBQUEsQ0FBQyxDQUFDO0tBQUE7Q0FDN0I7QUFWRCxzQ0FVQyIsImZpbGUiOiJjb21tYW5kcy91bmxpbmsvdW5saW5rLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoQykgMjAxOCBHYXJkZW4gVGVjaG5vbG9naWVzLCBJbmMuIDxpbmZvQGdhcmRlbi5pbz5cbiAqXG4gKiBUaGlzIFNvdXJjZSBDb2RlIEZvcm0gaXMgc3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhlIE1vemlsbGEgUHVibGljXG4gKiBMaWNlbnNlLCB2LiAyLjAuIElmIGEgY29weSBvZiB0aGUgTVBMIHdhcyBub3QgZGlzdHJpYnV0ZWQgd2l0aCB0aGlzXG4gKiBmaWxlLCBZb3UgY2FuIG9idGFpbiBvbmUgYXQgaHR0cDovL21vemlsbGEub3JnL01QTC8yLjAvLlxuICovXG5cbmltcG9ydCB7IENvbW1hbmQgfSBmcm9tIFwiLi4vYmFzZVwiXG5pbXBvcnQgeyBVbmxpbmtTb3VyY2VDb21tYW5kIH0gZnJvbSBcIi4vc291cmNlXCJcbmltcG9ydCB7IFVubGlua01vZHVsZUNvbW1hbmQgfSBmcm9tIFwiLi9tb2R1bGVcIlxuXG5leHBvcnQgY2xhc3MgVW5saW5rQ29tbWFuZCBleHRlbmRzIENvbW1hbmQge1xuICBuYW1lID0gXCJ1bmxpbmtcIlxuICBoZWxwID0gXCJVbmxpbmsgYSByZW1vdGUgc291cmNlIG9yIG1vZHVsZSBmcm9tIGl0cyBsb2NhbCBwYXRoXCJcblxuICBzdWJDb21tYW5kcyA9IFtcbiAgICBVbmxpbmtTb3VyY2VDb21tYW5kLFxuICAgIFVubGlua01vZHVsZUNvbW1hbmQsXG4gIF1cblxuICBhc3luYyBhY3Rpb24oKSB7IHJldHVybiB7fSB9XG59XG4iXX0= diff --git a/garden-service/build/commands/update-remote/all.d.ts b/garden-service/build/commands/update-remote/all.d.ts new file mode 100644 index 00000000000..22c849e8630 --- /dev/null +++ b/garden-service/build/commands/update-remote/all.d.ts @@ -0,0 +1,13 @@ +import { Command, CommandResult, CommandParams } from "../base"; +import { SourceConfig } from "../../config/project"; +export interface UpdateRemoteAllResult { + projectSources: SourceConfig[]; + moduleSources: SourceConfig[]; +} +export declare class UpdateRemoteAllCommand extends Command { + name: string; + help: string; + description: string; + action({ garden }: CommandParams): Promise>; +} +//# sourceMappingURL=all.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/update-remote/all.js b/garden-service/build/commands/update-remote/all.js new file mode 100644 index 00000000000..992ec3c069c --- /dev/null +++ b/garden-service/build/commands/update-remote/all.js @@ -0,0 +1,46 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const dedent = require("dedent"); +const base_1 = require("../base"); +const sources_1 = require("./sources"); +const modules_1 = require("./modules"); +class UpdateRemoteAllCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "all"; + this.help = "Update all remote sources and modules."; + this.description = dedent ` + Examples: + + garden update-remote all # update all remote sources and modules in the project + `; + } + action({ garden }) { + return __awaiter(this, void 0, void 0, function* () { + garden.log.header({ emoji: "hammer_and_wrench", command: "update-remote all" }); + const sourcesCmd = new sources_1.UpdateRemoteSourcesCommand(); + const modulesCmd = new modules_1.UpdateRemoteModulesCommand(); + const { result: projectSources } = yield sourcesCmd.action({ garden, args: { source: undefined }, opts: {} }); + const { result: moduleSources } = yield modulesCmd.action({ garden, args: { module: undefined }, opts: {} }); + return { result: { projectSources: projectSources, moduleSources: moduleSources } }; + }); + } +} +exports.UpdateRemoteAllCommand = UpdateRemoteAllCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/update-remote/helpers.d.ts b/garden-service/build/commands/update-remote/helpers.d.ts new file mode 100644 index 00000000000..5804896d96a --- /dev/null +++ b/garden-service/build/commands/update-remote/helpers.d.ts @@ -0,0 +1,8 @@ +import { ExternalSourceType } from "../../util/ext-source-util"; +import { SourceConfig } from "../../config/project"; +export declare function pruneRemoteSources({ projectRoot, sources, type }: { + projectRoot: string; + sources: SourceConfig[]; + type: ExternalSourceType; +}): Promise; +//# sourceMappingURL=helpers.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/update-remote/helpers.js b/garden-service/build/commands/update-remote/helpers.js new file mode 100644 index 00000000000..80709ad8767 --- /dev/null +++ b/garden-service/build/commands/update-remote/helpers.js @@ -0,0 +1,41 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const path_1 = require("path"); +const fs_extra_1 = require("fs-extra"); +const util_1 = require("../../util/util"); +const ext_source_util_1 = require("../../util/ext-source-util"); +function pruneRemoteSources({ projectRoot, sources, type }) { + return __awaiter(this, void 0, void 0, function* () { + const remoteSourcesPath = path_1.join(projectRoot, ext_source_util_1.getRemoteSourcesDirname(type)); + if (!(yield fs_extra_1.pathExists(remoteSourcesPath))) { + return; + } + const sourceNames = sources + .map(({ name, repositoryUrl: url }) => ext_source_util_1.getRemoteSourcePath({ name, url, sourceType: type })) + .map(srcPath => path_1.basename(srcPath)); + const currentRemoteSources = yield util_1.getChildDirNames(remoteSourcesPath); + const staleRemoteSources = lodash_1.difference(currentRemoteSources, sourceNames); + for (const dirName of staleRemoteSources) { + yield fs_extra_1.remove(path_1.join(remoteSourcesPath, dirName)); + } + }); +} +exports.pruneRemoteSources = pruneRemoteSources; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/update-remote/modules.d.ts b/garden-service/build/commands/update-remote/modules.d.ts new file mode 100644 index 00000000000..17ad7e6e4e1 --- /dev/null +++ b/garden-service/build/commands/update-remote/modules.d.ts @@ -0,0 +1,17 @@ +import { Command, StringsParameter, CommandResult, CommandParams } from "../base"; +import { SourceConfig } from "../../config/project"; +declare const updateRemoteModulesArguments: { + module: StringsParameter; +}; +declare type Args = typeof updateRemoteModulesArguments; +export declare class UpdateRemoteModulesCommand extends Command { + name: string; + help: string; + arguments: { + module: StringsParameter; + }; + description: string; + action({ garden, args }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=modules.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/update-remote/modules.js b/garden-service/build/commands/update-remote/modules.js new file mode 100644 index 00000000000..53bd6298153 --- /dev/null +++ b/garden-service/build/commands/update-remote/modules.js @@ -0,0 +1,75 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const dedent = require("dedent"); +const chalk_1 = require("chalk"); +const base_1 = require("../base"); +const exceptions_1 = require("../../exceptions"); +const helpers_1 = require("./helpers"); +const ext_source_util_1 = require("../../util/ext-source-util"); +const updateRemoteModulesArguments = { + module: new base_1.StringsParameter({ + help: "Name of the remote module(s) to update. Use comma separator to specify multiple modules.", + }), +}; +class UpdateRemoteModulesCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "modules"; + this.help = "Update remote modules."; + this.arguments = updateRemoteModulesArguments; + this.description = dedent ` + Remote modules are modules that have a repositoryUrl field + in their garden.yml config that points to a remote repository. + + Examples: + + garden update-remote modules # update all remote modules in the project + garden update-remote modules my-module # update remote module my-module + `; + } + action({ garden, args }) { + return __awaiter(this, void 0, void 0, function* () { + garden.log.header({ emoji: "hammer_and_wrench", command: "update-remote modules" }); + const { module } = args; + const modules = yield garden.getModules(module); + const moduleSources = modules + .filter(ext_source_util_1.hasRemoteSource) + .filter(src => module ? module.includes(src.name) : true); + const names = moduleSources.map(src => src.name); + const diff = lodash_1.difference(module, names); + if (diff.length > 0) { + const modulesWithRemoteSource = (yield garden.getModules()).filter(ext_source_util_1.hasRemoteSource).sort(); + throw new exceptions_1.ParameterError(`Expected module(s) ${chalk_1.default.underline(diff.join(","))} to have a remote source.`, { + modulesWithRemoteSource, + input: module ? module.sort() : undefined, + }); + } + // TODO Update remotes in parallel. Currently not possible since updating might + // trigger a username and password prompt from git. + for (const { name, repositoryUrl } of moduleSources) { + yield garden.vcs.updateRemoteSource({ name, url: repositoryUrl, sourceType: "module", logEntry: garden.log }); + } + yield helpers_1.pruneRemoteSources({ projectRoot: garden.projectRoot, type: "module", sources: moduleSources }); + return { result: moduleSources }; + }); + } +} +exports.UpdateRemoteModulesCommand = UpdateRemoteModulesCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/update-remote/sources.d.ts b/garden-service/build/commands/update-remote/sources.d.ts new file mode 100644 index 00000000000..01f37f74312 --- /dev/null +++ b/garden-service/build/commands/update-remote/sources.d.ts @@ -0,0 +1,17 @@ +import { Command, StringsParameter, CommandResult, CommandParams } from "../base"; +import { SourceConfig } from "../../config/project"; +declare const updateRemoteSourcesArguments: { + source: StringsParameter; +}; +declare type Args = typeof updateRemoteSourcesArguments; +export declare class UpdateRemoteSourcesCommand extends Command { + name: string; + help: string; + arguments: { + source: StringsParameter; + }; + description: string; + action({ garden, args }: CommandParams): Promise>; +} +export {}; +//# sourceMappingURL=sources.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/update-remote/sources.js b/garden-service/build/commands/update-remote/sources.js new file mode 100644 index 00000000000..2b6b36c08de --- /dev/null +++ b/garden-service/build/commands/update-remote/sources.js @@ -0,0 +1,71 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const dedent = require("dedent"); +const chalk_1 = require("chalk"); +const base_1 = require("../base"); +const exceptions_1 = require("../../exceptions"); +const helpers_1 = require("./helpers"); +const updateRemoteSourcesArguments = { + source: new base_1.StringsParameter({ + help: "Name of the remote source(s) to update. Use comma separator to specify multiple sources.", + }), +}; +class UpdateRemoteSourcesCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "sources"; + this.help = "Update remote sources."; + this.arguments = updateRemoteSourcesArguments; + this.description = dedent ` + Update the remote sources declared in the project config. + + Examples: + + garden update-remote sources # update all remote sources in the project config + garden update-remote sources my-source # update remote source my-source + `; + } + action({ garden, args }) { + return __awaiter(this, void 0, void 0, function* () { + garden.log.header({ emoji: "hammer_and_wrench", command: "update-remote sources" }); + const { source } = args; + const projectSources = garden.projectSources + .filter(src => source ? source.includes(src.name) : true); + const names = projectSources.map(src => src.name); + // TODO: Make external modules a cli type to avoid validation repetition + const diff = lodash_1.difference(source, names); + if (diff.length > 0) { + throw new exceptions_1.ParameterError(`Expected source(s) ${chalk_1.default.underline(diff.join(","))} to be specified in the project garden.yml config.`, { + remoteSources: garden.projectSources.map(s => s.name).sort(), + input: source ? source.sort() : undefined, + }); + } + // TODO Update remotes in parallel. Currently not possible since updating might + // trigger a username and password prompt from git. + for (const { name, repositoryUrl } of projectSources) { + yield garden.vcs.updateRemoteSource({ name, url: repositoryUrl, sourceType: "project", logEntry: garden.log }); + } + yield helpers_1.pruneRemoteSources({ projectRoot: garden.projectRoot, type: "project", sources: projectSources }); + return { result: projectSources }; + }); + } +} +exports.UpdateRemoteSourcesCommand = UpdateRemoteSourcesCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/commands/update-remote/update-remote.d.ts b/garden-service/build/commands/update-remote/update-remote.d.ts new file mode 100644 index 00000000000..0c31ea61ee3 --- /dev/null +++ b/garden-service/build/commands/update-remote/update-remote.d.ts @@ -0,0 +1,11 @@ +import { Command } from "../base"; +import { UpdateRemoteSourcesCommand } from "./sources"; +import { UpdateRemoteModulesCommand } from "./modules"; +import { UpdateRemoteAllCommand } from "./all"; +export declare class UpdateRemoteCommand extends Command { + name: string; + help: string; + subCommands: (typeof UpdateRemoteSourcesCommand | typeof UpdateRemoteModulesCommand | typeof UpdateRemoteAllCommand)[]; + action(): Promise<{}>; +} +//# sourceMappingURL=update-remote.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/update-remote/update-remote.js b/garden-service/build/commands/update-remote/update-remote.js new file mode 100644 index 00000000000..861bb734fc4 --- /dev/null +++ b/garden-service/build/commands/update-remote/update-remote.js @@ -0,0 +1,39 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("../base"); +const sources_1 = require("./sources"); +const modules_1 = require("./modules"); +const all_1 = require("./all"); +class UpdateRemoteCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "update-remote"; + this.help = "Pulls the latest version of remote sources or modules from their repository"; + this.subCommands = [ + sources_1.UpdateRemoteSourcesCommand, + modules_1.UpdateRemoteModulesCommand, + all_1.UpdateRemoteAllCommand, + ]; + } + action() { + return __awaiter(this, void 0, void 0, function* () { return {}; }); + } +} +exports.UpdateRemoteCommand = UpdateRemoteCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbW1hbmRzL3VwZGF0ZS1yZW1vdGUvdXBkYXRlLXJlbW90ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7O0FBRUgsa0NBQWlDO0FBQ2pDLHVDQUFzRDtBQUN0RCx1Q0FBc0Q7QUFDdEQsK0JBQThDO0FBRTlDLE1BQWEsbUJBQW9CLFNBQVEsY0FBTztJQUFoRDs7UUFDRSxTQUFJLEdBQUcsZUFBZSxDQUFBO1FBQ3RCLFNBQUksR0FBRyw2RUFBNkUsQ0FBQTtRQUVwRixnQkFBVyxHQUFHO1lBQ1osb0NBQTBCO1lBQzFCLG9DQUEwQjtZQUMxQiw0QkFBc0I7U0FDdkIsQ0FBQTtJQUdILENBQUM7SUFETyxNQUFNOzhEQUFLLE9BQU8sRUFBRSxDQUFBLENBQUMsQ0FBQztLQUFBO0NBQzdCO0FBWEQsa0RBV0MiLCJmaWxlIjoiY29tbWFuZHMvdXBkYXRlLXJlbW90ZS91cGRhdGUtcmVtb3RlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoQykgMjAxOCBHYXJkZW4gVGVjaG5vbG9naWVzLCBJbmMuIDxpbmZvQGdhcmRlbi5pbz5cbiAqXG4gKiBUaGlzIFNvdXJjZSBDb2RlIEZvcm0gaXMgc3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhlIE1vemlsbGEgUHVibGljXG4gKiBMaWNlbnNlLCB2LiAyLjAuIElmIGEgY29weSBvZiB0aGUgTVBMIHdhcyBub3QgZGlzdHJpYnV0ZWQgd2l0aCB0aGlzXG4gKiBmaWxlLCBZb3UgY2FuIG9idGFpbiBvbmUgYXQgaHR0cDovL21vemlsbGEub3JnL01QTC8yLjAvLlxuICovXG5cbmltcG9ydCB7IENvbW1hbmQgfSBmcm9tIFwiLi4vYmFzZVwiXG5pbXBvcnQgeyBVcGRhdGVSZW1vdGVTb3VyY2VzQ29tbWFuZCB9IGZyb20gXCIuL3NvdXJjZXNcIlxuaW1wb3J0IHsgVXBkYXRlUmVtb3RlTW9kdWxlc0NvbW1hbmQgfSBmcm9tIFwiLi9tb2R1bGVzXCJcbmltcG9ydCB7IFVwZGF0ZVJlbW90ZUFsbENvbW1hbmQgfSBmcm9tIFwiLi9hbGxcIlxuXG5leHBvcnQgY2xhc3MgVXBkYXRlUmVtb3RlQ29tbWFuZCBleHRlbmRzIENvbW1hbmQge1xuICBuYW1lID0gXCJ1cGRhdGUtcmVtb3RlXCJcbiAgaGVscCA9IFwiUHVsbHMgdGhlIGxhdGVzdCB2ZXJzaW9uIG9mIHJlbW90ZSBzb3VyY2VzIG9yIG1vZHVsZXMgZnJvbSB0aGVpciByZXBvc2l0b3J5XCJcblxuICBzdWJDb21tYW5kcyA9IFtcbiAgICBVcGRhdGVSZW1vdGVTb3VyY2VzQ29tbWFuZCxcbiAgICBVcGRhdGVSZW1vdGVNb2R1bGVzQ29tbWFuZCxcbiAgICBVcGRhdGVSZW1vdGVBbGxDb21tYW5kLFxuICBdXG5cbiAgYXN5bmMgYWN0aW9uKCkgeyByZXR1cm4ge30gfVxufVxuIl19 diff --git a/garden-service/build/commands/validate.d.ts b/garden-service/build/commands/validate.d.ts new file mode 100644 index 00000000000..eecb85ba8df --- /dev/null +++ b/garden-service/build/commands/validate.d.ts @@ -0,0 +1,8 @@ +import { Command, CommandParams, CommandResult } from "./base"; +export declare class ValidateCommand extends Command { + name: string; + help: string; + description: string; + action({ garden }: CommandParams): Promise; +} +//# sourceMappingURL=validate.d.ts.map \ No newline at end of file diff --git a/garden-service/build/commands/validate.js b/garden-service/build/commands/validate.js new file mode 100644 index 00000000000..ab6fbb09d50 --- /dev/null +++ b/garden-service/build/commands/validate.js @@ -0,0 +1,39 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = require("./base"); +const dedent = require("dedent"); +class ValidateCommand extends base_1.Command { + constructor() { + super(...arguments); + this.name = "validate"; + this.help = "Check your garden configuration for errors."; + this.description = dedent ` + Throws an error and exits with code 1 if something's not right in your garden.yml files. + `; + } + action({ garden }) { + return __awaiter(this, void 0, void 0, function* () { + garden.log.header({ emoji: "heavy_check_mark", command: "validate" }); + yield garden.getModules(); + return {}; + }); + } +} +exports.ValidateCommand = ValidateCommand; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbW1hbmRzL3ZhbGlkYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7QUFFSCxpQ0FJZTtBQUNmLGlDQUFpQztBQUVqQyxNQUFhLGVBQWdCLFNBQVEsY0FBTztJQUE1Qzs7UUFDRSxTQUFJLEdBQUcsVUFBVSxDQUFBO1FBQ2pCLFNBQUksR0FBRyw2Q0FBNkMsQ0FBQTtRQUVwRCxnQkFBVyxHQUFHLE1BQU0sQ0FBQTs7R0FFbkIsQ0FBQTtJQVNILENBQUM7SUFQTyxNQUFNLENBQUMsRUFBRSxNQUFNLEVBQWlCOztZQUNwQyxNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQTtZQUVyRSxNQUFNLE1BQU0sQ0FBQyxVQUFVLEVBQUUsQ0FBQTtZQUV6QixPQUFPLEVBQUUsQ0FBQTtRQUNYLENBQUM7S0FBQTtDQUNGO0FBZkQsMENBZUMiLCJmaWxlIjoiY29tbWFuZHMvdmFsaWRhdGUuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChDKSAyMDE4IEdhcmRlbiBUZWNobm9sb2dpZXMsIEluYy4gPGluZm9AZ2FyZGVuLmlvPlxuICpcbiAqIFRoaXMgU291cmNlIENvZGUgRm9ybSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGUgTW96aWxsYSBQdWJsaWNcbiAqIExpY2Vuc2UsIHYuIDIuMC4gSWYgYSBjb3B5IG9mIHRoZSBNUEwgd2FzIG5vdCBkaXN0cmlidXRlZCB3aXRoIHRoaXNcbiAqIGZpbGUsIFlvdSBjYW4gb2J0YWluIG9uZSBhdCBodHRwOi8vbW96aWxsYS5vcmcvTVBMLzIuMC8uXG4gKi9cblxuaW1wb3J0IHtcbiAgQ29tbWFuZCxcbiAgQ29tbWFuZFBhcmFtcyxcbiAgQ29tbWFuZFJlc3VsdCxcbn0gZnJvbSBcIi4vYmFzZVwiXG5pbXBvcnQgZGVkZW50ID0gcmVxdWlyZShcImRlZGVudFwiKVxuXG5leHBvcnQgY2xhc3MgVmFsaWRhdGVDb21tYW5kIGV4dGVuZHMgQ29tbWFuZCB7XG4gIG5hbWUgPSBcInZhbGlkYXRlXCJcbiAgaGVscCA9IFwiQ2hlY2sgeW91ciBnYXJkZW4gY29uZmlndXJhdGlvbiBmb3IgZXJyb3JzLlwiXG5cbiAgZGVzY3JpcHRpb24gPSBkZWRlbnRgXG4gICAgVGhyb3dzIGFuIGVycm9yIGFuZCBleGl0cyB3aXRoIGNvZGUgMSBpZiBzb21ldGhpbmcncyBub3QgcmlnaHQgaW4geW91ciBnYXJkZW4ueW1sIGZpbGVzLlxuICBgXG5cbiAgYXN5bmMgYWN0aW9uKHsgZ2FyZGVuIH06IENvbW1hbmRQYXJhbXMpOiBQcm9taXNlPENvbW1hbmRSZXN1bHQ+IHtcbiAgICBnYXJkZW4ubG9nLmhlYWRlcih7IGVtb2ppOiBcImhlYXZ5X2NoZWNrX21hcmtcIiwgY29tbWFuZDogXCJ2YWxpZGF0ZVwiIH0pXG5cbiAgICBhd2FpdCBnYXJkZW4uZ2V0TW9kdWxlcygpXG5cbiAgICByZXR1cm4ge31cbiAgfVxufVxuIl19 diff --git a/garden-service/build/config-store.d.ts b/garden-service/build/config-store.d.ts new file mode 100644 index 00000000000..b19aa01ef34 --- /dev/null +++ b/garden-service/build/config-store.d.ts @@ -0,0 +1,52 @@ +import { Primitive } from "./config/common"; +export declare type ConfigValue = Primitive | Primitive[] | Object[]; +export declare type SetManyParam = { + keyPath: Array; + value: ConfigValue; +}[]; +export declare abstract class ConfigStore { + private config; + protected configPath: string; + constructor(projectPath: string); + abstract getConfigPath(projectPath: string): string; + abstract validate(config: any): T; + /** + * Would've been nice to allow something like: set(["path", "to", "valA", valA], ["path", "to", "valB", valB]...) + * but Typescript support is missing at the moment + */ + set(param: SetManyParam): any; + set(keyPath: string[], value: ConfigValue): any; + get(): Promise; + get(keyPath: string[]): Promise; + clear(): Promise; + delete(keyPath: string[]): Promise; + private getConfig; + private updateConfig; + private ensureConfigFile; + private loadConfig; + private saveConfig; + private throwKeyNotFound; +} +export interface KubernetesLocalConfig { + username?: string; + "previous-usernames"?: Array; +} +export interface LinkedSource { + name: string; + path: string; +} +export interface LocalConfig { + kubernetes?: KubernetesLocalConfig; + linkedModuleSources?: LinkedSource[]; + linkedProjectSources?: LinkedSource[]; +} +export declare const localConfigKeys: { + kubernetes: "kubernetes"; + linkedModuleSources: "linkedModuleSources"; + linkedProjectSources: "linkedProjectSources"; +}; +export declare class LocalConfigStore extends ConfigStore { + getConfigPath(projectPath: any): string; + validate(config: any): LocalConfig; +} +//# sourceMappingURL=config-store.d.ts.map \ No newline at end of file diff --git a/garden-service/build/config-store.js b/garden-service/build/config-store.js new file mode 100644 index 00000000000..011ebc92acc --- /dev/null +++ b/garden-service/build/config-store.js @@ -0,0 +1,174 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const yaml = require("js-yaml"); +const path_1 = require("path"); +const fs_extra_1 = require("fs-extra"); +const lodash_1 = require("lodash"); +const common_1 = require("./config/common"); +const exceptions_1 = require("./exceptions"); +const util_1 = require("./util/util"); +const constants_1 = require("./constants"); +class ConfigStore { + constructor(projectPath) { + this.configPath = this.getConfigPath(projectPath); + this.config = null; + } + set(...args) { + return __awaiter(this, void 0, void 0, function* () { + let config = yield this.getConfig(); + let entries; + if (args.length === 1) { + entries = args[0]; + } + else { + entries = [{ keyPath: args[0], value: args[1] }]; + } + for (const { keyPath, value } of entries) { + config = this.updateConfig(config, keyPath, value); + } + yield this.saveConfig(config); + }); + } + get(keyPath) { + return __awaiter(this, void 0, void 0, function* () { + const config = yield this.getConfig(); + if (keyPath) { + const value = lodash_1.get(config, keyPath); + if (value === undefined) { + this.throwKeyNotFound(config, keyPath); + } + return value; + } + return config; + }); + } + clear() { + return __awaiter(this, void 0, void 0, function* () { + yield this.saveConfig({}); + }); + } + delete(keyPath) { + return __awaiter(this, void 0, void 0, function* () { + let config = yield this.getConfig(); + if (lodash_1.get(config, keyPath) === undefined) { + this.throwKeyNotFound(config, keyPath); + } + const success = lodash_1.unset(config, keyPath); + if (!success) { + throw new exceptions_1.LocalConfigError(`Unable to delete key ${keyPath.join(".")} in user config`, { + keyPath, + config, + }); + } + yield this.saveConfig(config); + }); + } + getConfig() { + return __awaiter(this, void 0, void 0, function* () { + if (!this.config) { + yield this.loadConfig(); + } + // Spreading does not work on generic types, see: https://github.com/Microsoft/TypeScript/issues/13557 + return Object.assign(this.config, {}); + }); + } + updateConfig(config, keyPath, value) { + let currentValue = config; + for (let i = 0; i < keyPath.length; i++) { + const k = keyPath[i]; + if (i === keyPath.length - 1) { + currentValue[k] = value; + } + else if (currentValue[k] === undefined) { + currentValue[k] = {}; + } + else if (!lodash_1.isPlainObject(currentValue[k])) { + const path = keyPath.slice(i + 1).join("."); + throw new exceptions_1.LocalConfigError(`Attempting to assign a nested key on non-object (current value at ${path}: ${currentValue[k]})`, { + currentValue: currentValue[k], + path, + }); + } + currentValue = currentValue[k]; + } + return config; + } + ensureConfigFile() { + return __awaiter(this, void 0, void 0, function* () { + yield fs_extra_1.ensureFile(this.configPath); + }); + } + loadConfig() { + return __awaiter(this, void 0, void 0, function* () { + yield this.ensureConfigFile(); + const config = (yield yaml.safeLoad((yield fs_extra_1.readFile(this.configPath)).toString())) || {}; + this.config = this.validate(config); + }); + } + saveConfig(config) { + return __awaiter(this, void 0, void 0, function* () { + this.config = null; + const validated = this.validate(config); + yield util_1.dumpYaml(this.configPath, validated); + this.config = validated; + }); + } + throwKeyNotFound(config, keyPath) { + throw new exceptions_1.LocalConfigError(`Could not find key ${keyPath.join(".")} in user config`, { + keyPath, + config, + }); + } +} +exports.ConfigStore = ConfigStore; +const kubernetesLocalConfigSchema = Joi.object() + .keys({ + username: common_1.joiIdentifier().allow("").optional(), + "previous-usernames": Joi.array().items(common_1.joiIdentifier()).optional(), +}) + .meta({ internal: true }); +const linkedSourceSchema = Joi.object() + .keys({ + name: common_1.joiIdentifier(), + path: Joi.string(), +}) + .meta({ internal: true }); +const localConfigSchemaKeys = { + kubernetes: kubernetesLocalConfigSchema, + linkedModuleSources: common_1.joiArray(linkedSourceSchema), + linkedProjectSources: common_1.joiArray(linkedSourceSchema), +}; +exports.localConfigKeys = Object.keys(localConfigSchemaKeys).reduce((acc, key) => { + acc[key] = key; + return acc; +}, {}); +const localConfigSchema = Joi.object() + .keys(localConfigSchemaKeys) + .meta({ internal: true }); +class LocalConfigStore extends ConfigStore { + getConfigPath(projectPath) { + return path_1.resolve(projectPath, constants_1.GARDEN_DIR_NAME, constants_1.LOCAL_CONFIG_FILENAME); + } + validate(config) { + return common_1.validate(config, localConfigSchema, { context: this.configPath, ErrorClass: exceptions_1.LocalConfigError }); + } +} +exports.LocalConfigStore = LocalConfigStore; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["config-store.ts"],"names":[],"mappings":"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","file":"config-store.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Joi from \"joi\"\nimport * as yaml from \"js-yaml\"\nimport { resolve } from \"path\"\nimport { ensureFile, readFile } from \"fs-extra\"\nimport { get, isPlainObject, unset } from \"lodash\"\n\nimport { joiIdentifier, Primitive, validate, joiArray } from \"./config/common\"\nimport { LocalConfigError } from \"./exceptions\"\nimport { dumpYaml } from \"./util/util\"\nimport { GARDEN_DIR_NAME, LOCAL_CONFIG_FILENAME } from \"./constants\"\n\nexport type ConfigValue = Primitive | Primitive[] | Object[]\n\nexport type SetManyParam = { keyPath: Array<string>, value: ConfigValue }[]\n\nexport abstract class ConfigStore<T extends object = any> {\n  private config: null | T\n  protected configPath: string\n\n  constructor(projectPath: string) {\n    this.configPath = this.getConfigPath(projectPath)\n    this.config = null\n  }\n\n  abstract getConfigPath(projectPath: string): string\n  abstract validate(config): T\n\n  /**\n   * Would've been nice to allow something like: set([\"path\", \"to\", \"valA\", valA], [\"path\", \"to\", \"valB\", valB]...)\n   * but Typescript support is missing at the moment\n   */\n  public async set(param: SetManyParam)\n  public async set(keyPath: string[], value: ConfigValue)\n  public async set(...args) {\n    let config = await this.getConfig()\n    let entries: SetManyParam\n\n    if (args.length === 1) {\n      entries = args[0]\n    } else {\n      entries = [{ keyPath: args[0], value: args[1] }]\n    }\n\n    for (const { keyPath, value } of entries) {\n      config = this.updateConfig(config, keyPath, value)\n    }\n\n    await this.saveConfig(config)\n  }\n\n  public async get(): Promise<T>\n  public async get(keyPath: string[]): Promise<Object | ConfigValue>\n  public async get(keyPath?: string[]): Promise<Object | ConfigValue> {\n    const config = await this.getConfig()\n\n    if (keyPath) {\n      const value = get(config, keyPath)\n\n      if (value === undefined) {\n        this.throwKeyNotFound(config, keyPath)\n      }\n\n      return value\n    }\n\n    return config\n  }\n\n  public async clear() {\n    await this.saveConfig(<T>{})\n  }\n\n  public async delete(keyPath: string[]) {\n    let config = await this.getConfig()\n    if (get(config, keyPath) === undefined) {\n      this.throwKeyNotFound(config, keyPath)\n    }\n    const success = unset(config, keyPath)\n    if (!success) {\n      throw new LocalConfigError(`Unable to delete key ${keyPath.join(\".\")} in user config`, {\n        keyPath,\n        config,\n      })\n    }\n    await this.saveConfig(config)\n  }\n\n  private async getConfig(): Promise<T> {\n    if (!this.config) {\n      await this.loadConfig()\n    }\n    // Spreading does not work on generic types, see: https://github.com/Microsoft/TypeScript/issues/13557\n    return Object.assign(this.config, {})\n\n  }\n\n  private updateConfig(config: T, keyPath: string[], value: ConfigValue): T {\n    let currentValue = config\n\n    for (let i = 0; i < keyPath.length; i++) {\n      const k = keyPath[i]\n\n      if (i === keyPath.length - 1) {\n        currentValue[k] = value\n      } else if (currentValue[k] === undefined) {\n        currentValue[k] = {}\n      } else if (!isPlainObject(currentValue[k])) {\n        const path = keyPath.slice(i + 1).join(\".\")\n\n        throw new LocalConfigError(\n          `Attempting to assign a nested key on non-object (current value at ${path}: ${currentValue[k]})`,\n          {\n            currentValue: currentValue[k],\n            path,\n          },\n        )\n      }\n\n      currentValue = currentValue[k]\n    }\n    return config\n  }\n\n  private async ensureConfigFile() {\n    await ensureFile(this.configPath)\n  }\n\n  private async loadConfig() {\n    await this.ensureConfigFile()\n    const config = await yaml.safeLoad((await readFile(this.configPath)).toString()) || {}\n\n    this.config = this.validate(config)\n  }\n\n  private async saveConfig(config: T) {\n    this.config = null\n    const validated = this.validate(config)\n    await dumpYaml(this.configPath, validated)\n    this.config = validated\n  }\n\n  private throwKeyNotFound(config: T, keyPath: string[]) {\n    throw new LocalConfigError(`Could not find key ${keyPath.join(\".\")} in user config`, {\n      keyPath,\n      config,\n    })\n  }\n\n}\n\n// TODO: Camel case previous usernames\nexport interface KubernetesLocalConfig {\n  username?: string\n  \"previous-usernames\"?: Array<string>\n}\n\nexport interface LinkedSource {\n  name: string\n  path: string\n}\n\nexport interface LocalConfig {\n  kubernetes?: KubernetesLocalConfig\n  linkedModuleSources?: LinkedSource[] // TODO Use KeyedSet instead of array\n  linkedProjectSources?: LinkedSource[]\n}\n\nconst kubernetesLocalConfigSchema = Joi.object()\n  .keys({\n    username: joiIdentifier().allow(\"\").optional(),\n    \"previous-usernames\": Joi.array().items(joiIdentifier()).optional(),\n  })\n  .meta({ internal: true })\n\nconst linkedSourceSchema = Joi.object()\n  .keys({\n    name: joiIdentifier(),\n    path: Joi.string(),\n  })\n  .meta({ internal: true })\n\nconst localConfigSchemaKeys = {\n  kubernetes: kubernetesLocalConfigSchema,\n  linkedModuleSources: joiArray(linkedSourceSchema),\n  linkedProjectSources: joiArray(linkedSourceSchema),\n}\n\nexport const localConfigKeys = Object.keys(localConfigSchemaKeys).reduce((acc, key) => {\n  acc[key] = key\n  return acc\n}, {}) as { [K in keyof typeof localConfigSchemaKeys]: K }\n\nconst localConfigSchema = Joi.object()\n  .keys(localConfigSchemaKeys)\n  .meta({ internal: true })\n\nexport class LocalConfigStore extends ConfigStore<LocalConfig> {\n\n  getConfigPath(projectPath): string {\n    return resolve(projectPath, GARDEN_DIR_NAME, LOCAL_CONFIG_FILENAME)\n  }\n\n  validate(config): LocalConfig {\n    return validate(\n      config,\n      localConfigSchema,\n      { context: this.configPath, ErrorClass: LocalConfigError },\n    )\n  }\n\n}\n"]} diff --git a/garden-service/build/config/base.d.ts b/garden-service/build/config/base.d.ts new file mode 100644 index 00000000000..b5fb1d37363 --- /dev/null +++ b/garden-service/build/config/base.d.ts @@ -0,0 +1,14 @@ +import { ModuleConfig } from "./module"; +import * as Joi from "joi"; +import { ProjectConfig } from "../config/project"; +export interface GardenConfig { + version: string; + dirname: string; + path: string; + module?: ModuleConfig; + project?: ProjectConfig; +} +export declare const configSchema: Joi.ObjectSchema; +export declare function loadConfig(projectRoot: string, path: string): Promise; +export declare function findProjectConfig(path: string): Promise; +//# sourceMappingURL=base.d.ts.map \ No newline at end of file diff --git a/garden-service/build/config/base.js b/garden-service/build/config/base.js new file mode 100644 index 00000000000..146d95022a8 --- /dev/null +++ b/garden-service/build/config/base.js @@ -0,0 +1,146 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const util_1 = require("../util/util"); +const module_1 = require("./module"); +const common_1 = require("./common"); +const exceptions_1 = require("../exceptions"); +const Joi = require("joi"); +const yaml = require("js-yaml"); +const fs_extra_1 = require("fs-extra"); +const project_1 = require("../config/project"); +const lodash_1 = require("lodash"); +const CONFIG_FILENAME = "garden.yml"; +exports.configSchema = Joi.object() + .keys({ + // TODO: should this be called apiVersion? + version: Joi.string() + .default("0") + .only("0") + .description("The schema version of the config file (currently not used)."), + dirname: Joi.string().meta({ internal: true }), + path: Joi.string().meta({ internal: true }), + module: module_1.baseModuleSpecSchema, + project: project_1.projectSchema, +}) + .optionalKeys(["module", "project"]) + .required() + .description("The garden.yml config file."); +const baseModuleSchemaKeys = Object.keys(module_1.baseModuleSpecSchema.describe().children); +function loadConfig(projectRoot, path) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: nicer error messages when load/validation fails + const absPath = path_1.join(path, CONFIG_FILENAME); + let fileData; + let spec; + // loadConfig returns null if config file is not found in the given directory + try { + fileData = yield fs_extra_1.readFile(absPath); + } + catch (err) { + return undefined; + } + try { + spec = yaml.safeLoad(fileData) || {}; + } + catch (err) { + throw new exceptions_1.ConfigurationError(`Could not parse ${CONFIG_FILENAME} in directory ${path} as valid YAML`, err); + } + if (spec.module) { + /* + We allow specifying modules by name only as a shorthand: + + dependencies: + - foo-module + - name: foo-module // same as the above + */ + if (spec.module.build && spec.module.build.dependencies) { + spec.module.build.dependencies = spec.module.build.dependencies + .map(dep => (typeof dep) === "string" ? { name: dep } : dep); + } + } + const parsed = common_1.validate(spec, exports.configSchema, { context: path_1.relative(projectRoot, absPath) }); + const dirname = path_1.basename(path); + const project = parsed.project; + let moduleConfig = parsed.module; + if (project) { + // we include the default local environment unless explicitly overridden + for (const env of project_1.defaultEnvironments) { + if (!util_1.findByName(project.environments, env.name)) { + project.environments.push(env); + } + } + // the default environment is the first specified environment in the config, unless specified + const defaultEnvironment = project.defaultEnvironment; + if (defaultEnvironment === "") { + project.defaultEnvironment = project.environments[0].name; + } + else { + if (!util_1.findByName(project.environments, defaultEnvironment)) { + throw new exceptions_1.ConfigurationError(`The specified default environment ${defaultEnvironment} is not defined`, { + defaultEnvironment, + availableEnvironments: util_1.getNames(project.environments), + }); + } + } + } + if (moduleConfig) { + // Built-in keys are validated here and the rest are put into the `spec` field + moduleConfig = { + allowPublish: moduleConfig.allowPublish, + build: moduleConfig.build, + description: moduleConfig.description, + name: moduleConfig.name, + path, + repositoryUrl: moduleConfig.repositoryUrl, + serviceConfigs: [], + spec: lodash_1.omit(moduleConfig, baseModuleSchemaKeys), + testConfigs: [], + type: moduleConfig.type, + variables: moduleConfig.variables, + }; + } + return { + version: parsed.version, + dirname, + path, + module: moduleConfig, + project, + }; + }); +} +exports.loadConfig = loadConfig; +function findProjectConfig(path) { + return __awaiter(this, void 0, void 0, function* () { + let config; + let sepCount = path.split(path_1.sep).length - 1; + for (let i = 0; i < sepCount; i++) { + config = yield loadConfig(path, path); + if (!config || !config.project) { + path = path_1.resolve(path, ".."); + } + else if (config.project) { + return config; + } + } + return config; + }); +} +exports.findProjectConfig = findProjectConfig; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["config/base.ts"],"names":[],"mappings":"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","file":"config/base.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { join, relative, basename, sep, resolve } from \"path\"\nimport {\n  findByName,\n  getNames,\n} from \"../util/util\"\nimport { baseModuleSpecSchema, ModuleConfig } from \"./module\"\nimport { validate } from \"./common\"\nimport { ConfigurationError } from \"../exceptions\"\nimport * as Joi from \"joi\"\nimport * as yaml from \"js-yaml\"\nimport { readFile } from \"fs-extra\"\nimport { defaultEnvironments, ProjectConfig, projectSchema } from \"../config/project\"\nimport { omit } from \"lodash\"\n\nconst CONFIG_FILENAME = \"garden.yml\"\n\nexport interface GardenConfig {\n  version: string\n  dirname: string\n  path: string\n  module?: ModuleConfig\n  project?: ProjectConfig\n}\n\nexport const configSchema = Joi.object()\n  .keys({\n    // TODO: should this be called apiVersion?\n    version: Joi.string()\n      .default(\"0\")\n      .only(\"0\")\n      .description(\"The schema version of the config file (currently not used).\"),\n    dirname: Joi.string().meta({ internal: true }),\n    path: Joi.string().meta({ internal: true }),\n    module: baseModuleSpecSchema,\n    project: projectSchema,\n  })\n  .optionalKeys([\"module\", \"project\"])\n  .required()\n  .description(\"The garden.yml config file.\")\n\nconst baseModuleSchemaKeys = Object.keys(baseModuleSpecSchema.describe().children)\n\nexport async function loadConfig(projectRoot: string, path: string): Promise<GardenConfig | undefined> {\n  // TODO: nicer error messages when load/validation fails\n  const absPath = join(path, CONFIG_FILENAME)\n  let fileData\n  let spec: any\n\n  // loadConfig returns null if config file is not found in the given directory\n  try {\n    fileData = await readFile(absPath)\n  } catch (err) {\n    return undefined\n  }\n\n  try {\n    spec = yaml.safeLoad(fileData) || {}\n  } catch (err) {\n    throw new ConfigurationError(`Could not parse ${CONFIG_FILENAME} in directory ${path} as valid YAML`, err)\n  }\n\n  if (spec.module) {\n    /*\n      We allow specifying modules by name only as a shorthand:\n\n        dependencies:\n          - foo-module\n          - name: foo-module // same as the above\n     */\n    if (spec.module.build && spec.module.build.dependencies) {\n      spec.module.build.dependencies = spec.module.build.dependencies\n        .map(dep => (typeof dep) === \"string\" ? { name: dep } : dep)\n    }\n  }\n\n  const parsed = <GardenConfig>validate(spec, configSchema, { context: relative(projectRoot, absPath) })\n\n  const dirname = basename(path)\n  const project = parsed.project\n  let moduleConfig = parsed.module\n\n  if (project) {\n    // we include the default local environment unless explicitly overridden\n    for (const env of defaultEnvironments) {\n      if (!findByName(project.environments, env.name)) {\n        project.environments.push(env)\n      }\n    }\n\n    // the default environment is the first specified environment in the config, unless specified\n    const defaultEnvironment = project.defaultEnvironment\n\n    if (defaultEnvironment === \"\") {\n      project.defaultEnvironment = project.environments[0].name\n    } else {\n      if (!findByName(project.environments, defaultEnvironment)) {\n        throw new ConfigurationError(`The specified default environment ${defaultEnvironment} is not defined`, {\n          defaultEnvironment,\n          availableEnvironments: getNames(project.environments),\n        })\n      }\n    }\n  }\n\n  if (moduleConfig) {\n    // Built-in keys are validated here and the rest are put into the `spec` field\n    moduleConfig = {\n      allowPublish: moduleConfig.allowPublish,\n      build: moduleConfig.build,\n      description: moduleConfig.description,\n      name: moduleConfig.name,\n      path,\n      repositoryUrl: moduleConfig.repositoryUrl,\n      serviceConfigs: [],\n      spec: omit(moduleConfig, baseModuleSchemaKeys),\n      testConfigs: [],\n      type: moduleConfig.type,\n      variables: moduleConfig.variables,\n    }\n  }\n\n  return {\n    version: parsed.version,\n    dirname,\n    path,\n    module: moduleConfig,\n    project,\n  }\n}\n\nexport async function findProjectConfig(path: string): Promise<GardenConfig | undefined> {\n  let config: GardenConfig | undefined\n\n  let sepCount = path.split(sep).length - 1\n  for (let i = 0; i < sepCount; i++) {\n    config = await loadConfig(path, path)\n    if (!config || !config.project) {\n      path = resolve(path, \"..\")\n    } else if (config.project) {\n      return config\n    }\n  }\n\n  return config\n}\n"]} diff --git a/garden-service/build/config/common.d.ts b/garden-service/build/config/common.d.ts new file mode 100644 index 00000000000..242e29a633e --- /dev/null +++ b/garden-service/build/config/common.d.ts @@ -0,0 +1,29 @@ +import { JoiObject } from "joi"; +import * as Joi from "joi"; +import { ConfigurationError, LocalConfigError } from "../exceptions"; +export declare type Primitive = string | number | boolean; +export interface PrimitiveMap { + [key: string]: Primitive; +} +export interface DeepPrimitiveMap { + [key: string]: Primitive | DeepPrimitiveMap; +} +export declare const enumToArray: (Enum: any) => string[]; +export declare const joiPrimitive: () => Joi.AlternativesSchema; +export declare const identifierRegex: RegExp; +export declare const envVarRegex: RegExp; +export declare const joiIdentifier: () => Joi.StringSchema; +export declare const joiStringMap: (valueSchema: JoiObject) => Joi.ObjectSchema; +export declare const joiIdentifierMap: (valueSchema: JoiObject) => Joi.ObjectSchema; +export declare const joiVariables: () => Joi.ObjectSchema; +export declare const joiEnvVarName: () => Joi.StringSchema; +export declare const joiEnvVars: () => Joi.ObjectSchema; +export declare const joiArray: (schema: any) => Joi.ArraySchema; +export declare const joiRepositoryUrl: () => Joi.StringSchema; +export declare function isPrimitive(value: any): boolean; +export interface ValidateOptions { + context?: string; + ErrorClass?: typeof ConfigurationError | typeof LocalConfigError; +} +export declare function validate(value: T, schema: Joi.Schema, { context, ErrorClass }?: ValidateOptions): T; +//# sourceMappingURL=common.d.ts.map \ No newline at end of file diff --git a/garden-service/build/config/common.js b/garden-service/build/config/common.js new file mode 100644 index 00000000000..b8de11c68d6 --- /dev/null +++ b/garden-service/build/config/common.js @@ -0,0 +1,129 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const uuid = require("uuid"); +const exceptions_1 = require("../exceptions"); +const chalk_1 = require("chalk"); +// export type ConfigWithSpec = { +// spec: Omit & Partial +// } +exports.enumToArray = Enum => Object.values(Enum).filter(k => typeof k === "string"); +exports.joiPrimitive = () => Joi.alternatives().try(Joi.number(), Joi.string(), Joi.boolean()) + .description("Number, string or boolean"); +exports.identifierRegex = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/; +exports.envVarRegex = /^(?!GARDEN)[A-Z_][A-Z0-9_]*$/; +exports.joiIdentifier = () => Joi.string() + .regex(exports.identifierRegex) + .max(63) + .description("Valid RFC1035/RFC1123 (DNS) label (may contain lowercase letters, numbers and dashes, must start with a letter, " + + "and cannot end with a dash) and additionally cannot contain consecutive dashes or be longer than 63 characters."); +exports.joiStringMap = (valueSchema) => Joi + .object().pattern(/.+/, valueSchema); +exports.joiIdentifierMap = (valueSchema) => Joi + .object().pattern(exports.identifierRegex, valueSchema) + .default(() => ({}), "{}") + .description("Key/value map, keys must be valid identifiers."); +exports.joiVariables = () => Joi + .object().pattern(/[\w\d]+/i, exports.joiPrimitive()) + .default(() => ({}), "{}") + .unknown(false) + .description("Key/value map, keys may contain letters and numbers, and values must be primitives."); +exports.joiEnvVarName = () => Joi + .string().regex(exports.envVarRegex) + .description("Valid POSIX environment variable name (may contain letters, numbers and underscores and must start with a " + + "letter). Must be uppercase, and must not start with `GARDEN`."); +exports.joiEnvVars = () => Joi + .object().pattern(exports.envVarRegex, exports.joiPrimitive()) + .default(() => ({}), "{}") + .unknown(false) + .description("Key/value map of environment variables. Keys must be valid POSIX environment variable names " + + "(must be uppercase, may not start with `GARDEN`) and values must be primitives."); +exports.joiArray = (schema) => Joi + .array().items(schema) + .default(() => [], "[]"); +exports.joiRepositoryUrl = () => Joi + .string() + .uri({ + // TODO Support other protocols? + scheme: [ + "git", + /git\+https?/, + "https", + "file", + ], +}) + .description("A remote respository URL. Currently only supports git servers. Use hash notation (#) to point to" + + " a specific branch or tag") + .example("# or git+https://github.com/organization/some-module.git#v2.0"); +function isPrimitive(value) { + return typeof value === "string" || typeof value === "number" || typeof value === "boolean"; +} +exports.isPrimitive = isPrimitive; +const joiPathPlaceholder = uuid.v4(); +const joiPathPlaceholderRegex = new RegExp(joiPathPlaceholder, "g"); +const joiOptions = { + abortEarly: false, + language: { + key: `key ${joiPathPlaceholder} `, + object: { + allowUnknown: `!!key "{{!child}}" is not allowed at path ${joiPathPlaceholder}`, + child: "!!\"{{!child}}\": {{reason}}", + xor: `!!object at ${joiPathPlaceholder} only allows one of {{peersWithLabels}}`, + }, + }, +}; +function validate(value, schema, { context = "", ErrorClass = exceptions_1.ConfigurationError } = {}) { + const result = schema.validate(value, joiOptions); + const error = result.error; + if (error) { + const description = schema.describe(); + const errorDetails = error.details.map((e) => { + // render the key path in a much nicer way + let renderedPath = "."; + if (e.path.length) { + renderedPath = ""; + let d = description; + for (const part of e.path) { + if (d.children && d.children[part]) { + renderedPath += "." + part; + d = d.children[part]; + } + else if (d.patterns) { + for (const p of d.patterns) { + if (part.match(new RegExp(p.regex.slice(1, -1)))) { + renderedPath += `[${part}]`; + d = p.rule; + break; + } + } + } + else { + renderedPath += `[${part}]`; + } + } + } + // a little hack to always use full key paths instead of just the label + e.message = e.message.replace(joiPathPlaceholderRegex, chalk_1.default.underline(renderedPath || ".")); + return e; + }); + const msgPrefix = context ? `Error validating ${context}` : "Validation error"; + const errorDescription = errorDetails.map(e => e.message).join(", "); + throw new ErrorClass(`${msgPrefix}: ${errorDescription}`, { + value, + context, + errorDescription, + errorDetails, + }); + } + return result.value; +} +exports.validate = validate; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["config/common.ts"],"names":[],"mappings":"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","file":"config/common.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { JoiObject } from \"joi\"\nimport * as Joi from \"joi\"\nimport * as uuid from \"uuid\"\nimport { ConfigurationError, LocalConfigError } from \"../exceptions\"\nimport chalk from \"chalk\"\n\nexport type Primitive = string | number | boolean\n\nexport interface PrimitiveMap { [key: string]: Primitive }\nexport interface DeepPrimitiveMap { [key: string]: Primitive | DeepPrimitiveMap }\n\n// export type ConfigWithSpec<S extends object> = <T extends S>{\n//   spec: Omit<T, keyof S> & Partial<S>\n// }\n\nexport const enumToArray = Enum => (\n  Object.values(Enum).filter(k => typeof k === \"string\") as string[]\n)\n\nexport const joiPrimitive = () => Joi.alternatives().try(Joi.number(), Joi.string(), Joi.boolean())\n  .description(\"Number, string or boolean\")\n\nexport const identifierRegex = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/\nexport const envVarRegex = /^(?!GARDEN)[A-Z_][A-Z0-9_]*$/\n\nexport const joiIdentifier = () => Joi.string()\n  .regex(identifierRegex)\n  .max(63)\n  .description(\n    \"Valid RFC1035/RFC1123 (DNS) label (may contain lowercase letters, numbers and dashes, must start with a letter, \" +\n    \"and cannot end with a dash) and additionally cannot contain consecutive dashes or be longer than 63 characters.\",\n  )\n\nexport const joiStringMap = (valueSchema: JoiObject) => Joi\n  .object().pattern(/.+/, valueSchema)\n\nexport const joiIdentifierMap = (valueSchema: JoiObject) => Joi\n  .object().pattern(identifierRegex, valueSchema)\n  .default(() => ({}), \"{}\")\n  .description(\"Key/value map, keys must be valid identifiers.\")\n\nexport const joiVariables = () => Joi\n  .object().pattern(/[\\w\\d]+/i, joiPrimitive())\n  .default(() => ({}), \"{}\")\n  .unknown(false)\n  .description(\"Key/value map, keys may contain letters and numbers, and values must be primitives.\")\n\nexport const joiEnvVarName = () => Joi\n  .string().regex(envVarRegex)\n  .description(\n    \"Valid POSIX environment variable name (may contain letters, numbers and underscores and must start with a \" +\n    \"letter). Must be uppercase, and must not start with `GARDEN`.\",\n  )\n\nexport const joiEnvVars = () => Joi\n  .object().pattern(envVarRegex, joiPrimitive())\n  .default(() => ({}), \"{}\")\n  .unknown(false)\n  .description(\n    \"Key/value map of environment variables. Keys must be valid POSIX environment variable names \" +\n    \"(must be uppercase, may not start with `GARDEN`) and values must be primitives.\",\n  )\n\nexport const joiArray = (schema) => Joi\n  .array().items(schema)\n  .default(() => [], \"[]\")\n\nexport const joiRepositoryUrl = () => Joi\n  .string()\n  .uri({\n    // TODO Support other protocols?\n    scheme: [\n      \"git\",\n      /git\\+https?/,\n      \"https\",\n      \"file\",\n    ],\n  })\n  .description(\n    \"A remote respository URL. Currently only supports git servers. Use hash notation (#) to point to\" +\n    \" a specific branch or tag\",\n  )\n  .example(\"<git remote url>#<branch|tag> or git+https://github.com/organization/some-module.git#v2.0\")\n\nexport function isPrimitive(value: any) {\n  return typeof value === \"string\" || typeof value === \"number\" || typeof value === \"boolean\"\n}\n\nconst joiPathPlaceholder = uuid.v4()\nconst joiPathPlaceholderRegex = new RegExp(joiPathPlaceholder, \"g\")\nconst joiOptions = {\n  abortEarly: false,\n  language: {\n    key: `key ${joiPathPlaceholder} `,\n    object: {\n      allowUnknown: `!!key \"{{!child}}\" is not allowed at path ${joiPathPlaceholder}`,\n      child: \"!!\\\"{{!child}}\\\": {{reason}}\",\n      xor: `!!object at ${joiPathPlaceholder} only allows one of {{peersWithLabels}}`,\n    },\n  },\n}\n\nexport interface ValidateOptions {\n  context?: string\n  ErrorClass?: typeof ConfigurationError | typeof LocalConfigError\n}\n\nexport function validate<T>(\n  value: T,\n  schema: Joi.Schema,\n  { context = \"\", ErrorClass = ConfigurationError }: ValidateOptions = {},\n): T {\n  const result = schema.validate(value, joiOptions)\n  const error = result.error\n\n  if (error) {\n    const description = schema.describe()\n\n    const errorDetails = error.details.map((e) => {\n      // render the key path in a much nicer way\n      let renderedPath = \".\"\n\n      if (e.path.length) {\n        renderedPath = \"\"\n        let d = description\n\n        for (const part of e.path) {\n          if (d.children && d.children[part]) {\n            renderedPath += \".\" + part\n            d = d.children[part]\n          } else if (d.patterns) {\n            for (const p of d.patterns) {\n              if (part.match(new RegExp(p.regex.slice(1, -1)))) {\n                renderedPath += `[${part}]`\n                d = p.rule\n                break\n              }\n            }\n          } else {\n            renderedPath += `[${part}]`\n          }\n        }\n      }\n\n      // a little hack to always use full key paths instead of just the label\n      e.message = e.message.replace(joiPathPlaceholderRegex, chalk.underline(renderedPath || \".\"))\n\n      return e\n    })\n\n    const msgPrefix = context ? `Error validating ${context}` : \"Validation error\"\n    const errorDescription = errorDetails.map(e => e.message).join(\", \")\n\n    throw new ErrorClass(`${msgPrefix}: ${errorDescription}`, {\n      value,\n      context,\n      errorDescription,\n      errorDetails,\n    })\n  }\n\n  return result.value\n}\n"]} diff --git a/garden-service/build/config/config-context.d.ts b/garden-service/build/config/config-context.d.ts new file mode 100644 index 00000000000..67b29439af2 --- /dev/null +++ b/garden-service/build/config/config-context.d.ts @@ -0,0 +1,62 @@ +import { Module } from "../types/module"; +import { PrimitiveMap, Primitive } from "./common"; +import { Provider, Environment } from "./project"; +import { ModuleConfig } from "./module"; +import { Service } from "../types/service"; +import * as Joi from "joi"; +import { Garden } from "../garden"; +export declare type ContextKey = string[]; +export interface ContextResolveParams { + key: ContextKey; + nodePath: ContextKey; + stack?: string[]; +} +export declare function schema(joiSchema: Joi.Schema): (target: any, propName: any) => void; +export declare abstract class ConfigContext { + private readonly _rootContext; + private readonly _resolvedValues; + constructor(rootContext?: ConfigContext); + static getSchema(): Joi.ObjectSchema; + resolve({ key, nodePath, stack }: ContextResolveParams): Promise; +} +declare class LocalContext extends ConfigContext { + env: typeof process.env; + platform: string; + constructor(root: ConfigContext); +} +/** + * This context is available for template strings under the `project` key in configuration files. + */ +export declare class ProjectConfigContext extends ConfigContext { + local: LocalContext; + constructor(); +} +declare class EnvironmentContext extends ConfigContext { + name: string; + constructor(root: ConfigContext, name: string); +} +declare class ModuleContext extends ConfigContext { + path: string; + version: string; + buildPath: string; + constructor(root: ConfigContext, module: Module); +} +declare class ServiceContext extends ConfigContext { + outputs: PrimitiveMap; + version: string; + constructor(root: ConfigContext, service: Service, outputs: PrimitiveMap); +} +/** + * This context is available for template strings under the `module` key in configuration files. + * It is a superset of the context available under the `project` key. + */ +export declare class ModuleConfigContext extends ProjectConfigContext { + environment: EnvironmentContext; + modules: Map Promise>; + services: Map Promise>; + providers: Map; + variables: PrimitiveMap; + constructor(garden: Garden, environment: Environment, moduleConfigs: ModuleConfig[]); +} +export {}; +//# sourceMappingURL=config-context.d.ts.map \ No newline at end of file diff --git a/garden-service/build/config/config-context.js b/garden-service/build/config/config-context.js new file mode 100644 index 00000000000..5be6a5bedd9 --- /dev/null +++ b/garden-service/build/config/config-context.js @@ -0,0 +1,271 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const common_1 = require("./common"); +const project_1 = require("./project"); +const exceptions_1 = require("../exceptions"); +const template_string_1 = require("../template-string"); +const Joi = require("joi"); +function schema(joiSchema) { + return (target, propName) => { + target.constructor._schemas = Object.assign({}, target.constructor._schemas || {}, { [propName]: joiSchema }); + }; +} +exports.schema = schema; +// Note: we're using classes here to be able to use decorators to describe each context node and key +class ConfigContext { + constructor(rootContext) { + this._rootContext = rootContext || this; + this._resolvedValues = {}; + } + static getSchema() { + const schemas = this._schemas; + return Joi.object().keys(schemas).required(); + } + resolve({ key, nodePath, stack }) { + return __awaiter(this, void 0, void 0, function* () { + const path = key.join("."); + const fullPath = nodePath.concat(key).join("."); + // if the key has previously been resolved, return it directly + const resolved = this._resolvedValues[path]; + if (resolved) { + return resolved; + } + stack = [...stack || []]; + if (stack.includes(fullPath)) { + throw new exceptions_1.ConfigurationError(`Circular reference detected when resolving key ${path} (${stack.join(" -> ")})`, { + nodePath, + fullPath, + stack, + }); + } + // keep track of which resolvers have been called, in order to detect circular references + let value = this; + for (let p = 0; p < key.length; p++) { + const nextKey = key[p]; + const lookupPath = key.slice(0, p + 1); + const remainder = key.slice(p + 1); + const nestedNodePath = nodePath.concat(lookupPath); + const stackEntry = nestedNodePath.join("."); + if (nextKey.startsWith("_")) { + value = undefined; + } + else { + value = value instanceof Map ? value.get(nextKey) : value[nextKey]; + } + if (typeof value === "function") { + // call the function to resolve the value, then continue + value = yield value(); + } + // handle nested contexts + if (value instanceof ConfigContext) { + const nestedKey = remainder; + stack.push(stackEntry); + value = yield value.resolve({ key: nestedKey, nodePath: nestedNodePath, stack }); + break; + } + // handle templated strings in context variables + if (lodash_1.isString(value)) { + stack.push(stackEntry); + value = yield template_string_1.resolveTemplateString(value, this._rootContext, stack); + } + if (value === undefined) { + break; + } + } + if (value === undefined) { + throw new exceptions_1.ConfigurationError(`Could not find key: ${path}`, { + nodePath, + fullPath, + stack, + }); + } + if (!common_1.isPrimitive(value)) { + throw new exceptions_1.ConfigurationError(`Config value at ${path} exists but is not a primitive (string, number or boolean)`, { + value, + path, + fullPath, + context, + }); + } + this._resolvedValues[path] = value; + return value; + }); + } +} +exports.ConfigContext = ConfigContext; +class LocalContext extends ConfigContext { + constructor(root) { + super(root); + this.env = process.env; + this.platform = process.platform; + } +} +__decorate([ + schema(common_1.joiStringMap(Joi.string()).description("A map of all local environment variables (see https://nodejs.org/api/process.html#process_process_env).")), + __metadata("design:type", Object) +], LocalContext.prototype, "env", void 0); +__decorate([ + schema(Joi.string() + .description("A string indicating the platform that the framework is running on " + + "(see https://nodejs.org/api/process.html#process_process_platform)") + .example("posix")), + __metadata("design:type", String) +], LocalContext.prototype, "platform", void 0); +/** + * This context is available for template strings under the `project` key in configuration files. + */ +class ProjectConfigContext extends ConfigContext { + constructor() { + super(); + this.local = new LocalContext(this); + } +} +__decorate([ + schema(LocalContext.getSchema()), + __metadata("design:type", LocalContext) +], ProjectConfigContext.prototype, "local", void 0); +exports.ProjectConfigContext = ProjectConfigContext; +class EnvironmentContext extends ConfigContext { + constructor(root, name) { + super(root); + this.name = name; + } +} +__decorate([ + schema(Joi.string() + .description("The name of the environment Garden is running against.") + .example("local")), + __metadata("design:type", String) +], EnvironmentContext.prototype, "name", void 0); +const exampleVersion = "v17ad4cb3fd"; +class ModuleContext extends ConfigContext { + constructor(root, module) { + super(root); + this.path = module.path; + this.version = module.version.versionString; + this.buildPath = module.buildPath; + } +} +__decorate([ + schema(Joi.string().description("The local path of the module.").example("/home/me/code/my-project/my-module")), + __metadata("design:type", String) +], ModuleContext.prototype, "path", void 0); +__decorate([ + schema(Joi.string().description("The current version of the module.").example(exampleVersion)), + __metadata("design:type", String) +], ModuleContext.prototype, "version", void 0); +__decorate([ + schema(Joi.string() + .description("The build path of the module.") + .example("/home/me/code/my-project/.garden/build/my-module")), + __metadata("design:type", String) +], ModuleContext.prototype, "buildPath", void 0); +const exampleOutputs = { ingress: "http://my-service/path/to/endpoint" }; +class ServiceContext extends ConfigContext { + // TODO: add ingresses + constructor(root, service, outputs) { + super(root); + this.outputs = outputs; + this.version = service.module.version.versionString; + } +} +__decorate([ + schema(common_1.joiIdentifierMap(common_1.joiPrimitive() + .description("The outputs defined by the service (see individual plugins for details).") + .example(exampleOutputs))), + __metadata("design:type", Object) +], ServiceContext.prototype, "outputs", void 0); +__decorate([ + schema(Joi.string().description("The current version of the service.").example(exampleVersion)), + __metadata("design:type", String) +], ServiceContext.prototype, "version", void 0); +/** + * This context is available for template strings under the `module` key in configuration files. + * It is a superset of the context available under the `project` key. + */ +class ModuleConfigContext extends ProjectConfigContext { + constructor(garden, environment, moduleConfigs) { + super(); + const _this = this; + this.environment = new EnvironmentContext(_this, environment.name); + this.modules = new Map(moduleConfigs.map((config) => [config.name, () => __awaiter(this, void 0, void 0, function* () { + const module = yield garden.getModule(config.name); + return new ModuleContext(_this, module); + })])); + const serviceNames = lodash_1.flatten(moduleConfigs.map(m => m.serviceConfigs)).map(s => s.name); + this.services = new Map(serviceNames.map((name) => [name, () => __awaiter(this, void 0, void 0, function* () { + const service = yield garden.getService(name); + const outputs = Object.assign({}, service.config.outputs, yield garden.actions.getServiceOutputs({ service })); + return new ServiceContext(_this, service, outputs); + })])); + this.providers = new Map(environment.providers.map(p => [p.name, p])); + // this.config = new SecretsContextNode(ctx) + this.variables = environment.variables; + } +} +__decorate([ + schema(EnvironmentContext.getSchema() + .description("Information about the environment that Garden is running against.")), + __metadata("design:type", EnvironmentContext) +], ModuleConfigContext.prototype, "environment", void 0); +__decorate([ + schema(common_1.joiIdentifierMap(ModuleContext.getSchema()) + .description("Retrieve information about modules that are defined in the project.") + .example({ "my-module": { path: "/home/me/code/my-project/my-module", version: exampleVersion } })), + __metadata("design:type", Map) +], ModuleConfigContext.prototype, "modules", void 0); +__decorate([ + schema(common_1.joiIdentifierMap(ServiceContext.getSchema()) + .description("Retrieve information about services that are defined in the project.") + .example({ "my-service": { outputs: exampleOutputs, version: exampleVersion } })), + __metadata("design:type", Map) +], ModuleConfigContext.prototype, "services", void 0); +__decorate([ + schema(common_1.joiIdentifierMap(project_1.providerConfigBaseSchema) + .description("A map of all configured plugins/providers for this environment and their configuration.") + .example({ kubernetes: { name: "local-kubernetes", context: "my-kube-context" } })), + __metadata("design:type", Map) +], ModuleConfigContext.prototype, "providers", void 0); +__decorate([ + schema(common_1.joiIdentifierMap(common_1.joiPrimitive()) + .description("A map of all variables defined in the project configuration.") + .example({ "team-name": "bananaramallama", "some-service-endpoint": "https://someservice.com/api/v2" })), + __metadata("design:type", Object) +], ModuleConfigContext.prototype, "variables", void 0); +exports.ModuleConfigContext = ModuleConfigContext; +// class RemoteConfigContext extends ConfigContext { +// constructor(private ctx: PluginContext) { +// super() +// } +// async resolve({ key }: ResolveParams) { +// const { value } = await this.ctx.getSecret({ key }) +// return value === null ? undefined : value +// } +// } + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["config/config-context.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;AAEH,mCAA0C;AAE1C,qCAA6G;AAC7G,uCAA2E;AAE3E,8CAAkD;AAElD,wDAA0D;AAC1D,2BAA0B;AAY1B,SAAgB,MAAM,CAAC,SAAqB;IAC1C,OAAO,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE;QAC1B,MAAM,CAAC,WAAW,CAAC,QAAQ,qBAAQ,MAAM,CAAC,WAAW,CAAC,QAAQ,IAAI,EAAE,IAAE,CAAC,QAAQ,CAAC,EAAE,SAAS,GAAE,CAAA;IAC/F,CAAC,CAAA;AACH,CAAC;AAJD,wBAIC;AAED,oGAAoG;AACpG,MAAsB,aAAa;IAIjC,YAAY,WAA2B;QACrC,IAAI,CAAC,YAAY,GAAG,WAAW,IAAI,IAAI,CAAA;QACvC,IAAI,CAAC,eAAe,GAAG,EAAE,CAAA;IAC3B,CAAC;IAED,MAAM,CAAC,SAAS;QACd,MAAM,OAAO,GAAS,IAAK,CAAC,QAAQ,CAAA;QACpC,OAAO,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAA;IAC9C,CAAC;IAEK,OAAO,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAwB;;YAC1D,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YAC1B,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YAE/C,8DAA8D;YAC9D,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAA;YAE3C,IAAI,QAAQ,EAAE;gBACZ,OAAO,QAAQ,CAAA;aAChB;YAED,KAAK,GAAG,CAAC,GAAG,KAAK,IAAI,EAAE,CAAC,CAAA;YAExB,IAAI,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;gBAC5B,MAAM,IAAI,+BAAkB,CAC1B,kDAAkD,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAChF;oBACE,QAAQ;oBACR,QAAQ;oBACR,KAAK;iBACN,CACF,CAAA;aACF;YAED,yFAAyF;YACzF,IAAI,KAAK,GAAQ,IAAI,CAAA;YAErB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACnC,MAAM,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,CAAA;gBACtB,MAAM,UAAU,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;gBACtC,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;gBAClC,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;gBAClD,MAAM,UAAU,GAAG,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;gBAE3C,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;oBAC3B,KAAK,GAAG,SAAS,CAAA;iBAClB;qBAAM;oBACL,KAAK,GAAG,KAAK,YAAY,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;iBACnE;gBAED,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE;oBAC/B,wDAAwD;oBACxD,KAAK,GAAG,MAAM,KAAK,EAAE,CAAA;iBACtB;gBAED,yBAAyB;gBACzB,IAAI,KAAK,YAAY,aAAa,EAAE;oBAClC,MAAM,SAAS,GAAG,SAAS,CAAA;oBAC3B,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;oBACtB,KAAK,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,CAAA;oBAChF,MAAK;iBACN;gBAED,gDAAgD;gBAChD,IAAI,iBAAQ,CAAC,KAAK,CAAC,EAAE;oBACnB,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;oBACtB,KAAK,GAAG,MAAM,uCAAqB,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAA;iBACrE;gBAED,IAAI,KAAK,KAAK,SAAS,EAAE;oBACvB,MAAK;iBACN;aACF;YAED,IAAI,KAAK,KAAK,SAAS,EAAE;gBACvB,MAAM,IAAI,+BAAkB,CAAC,uBAAuB,IAAI,EAAE,EAAE;oBAC1D,QAAQ;oBACR,QAAQ;oBACR,KAAK;iBACN,CAAC,CAAA;aACH;YAED,IAAI,CAAC,oBAAW,CAAC,KAAK,CAAC,EAAE;gBACvB,MAAM,IAAI,+BAAkB,CAC1B,mBAAmB,IAAI,4DAA4D,EACnF;oBACE,KAAK;oBACL,IAAI;oBACJ,QAAQ;oBACR,OAAO;iBACR,CACF,CAAA;aACF;YAED,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,KAAK,CAAA;YAClC,OAAO,KAAK,CAAA;QACd,CAAC;KAAA;CACF;AArGD,sCAqGC;AAED,MAAM,YAAa,SAAQ,aAAa;IAkBtC,YAAY,IAAmB;QAC7B,KAAK,CAAC,IAAI,CAAC,CAAA;QACX,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,CAAA;QACtB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAA;IAClC,CAAC;CACF;AAjBC;IALC,MAAM,CACL,qBAAY,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,WAAW,CACpC,yGAAyG,CAC1G,CACF;;yCAC6B;AAU9B;IARC,MAAM,CACL,GAAG,CAAC,MAAM,EAAE;SACT,WAAW,CACV,oEAAoE;QACpE,oEAAoE,CACrE;SACA,OAAO,CAAC,OAAO,CAAC,CACpB;;8CACsB;AASzB;;GAEG;AACH,MAAa,oBAAqB,SAAQ,aAAa;IAIrD;QACE,KAAK,EAAE,CAAA;QACP,IAAI,CAAC,KAAK,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAA;IACrC,CAAC;CACF;AANC;IADC,MAAM,CAAC,YAAY,CAAC,SAAS,EAAE,CAAC;8BACnB,YAAY;mDAAA;AAF5B,oDAQC;AAED,MAAM,kBAAmB,SAAQ,aAAa;IAQ5C,YAAY,IAAmB,EAAE,IAAY;QAC3C,KAAK,CAAC,IAAI,CAAC,CAAA;QACX,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;CACF;AANC;IALC,MAAM,CACL,GAAG,CAAC,MAAM,EAAE;SACT,WAAW,CAAC,wDAAwD,CAAC;SACrE,OAAO,CAAC,OAAO,CAAC,CACpB;;gDACkB;AAQrB,MAAM,cAAc,GAAG,aAAa,CAAA;AAEpC,MAAM,aAAc,SAAQ,aAAa;IAcvC,YAAY,IAAmB,EAAE,MAAc;QAC7C,KAAK,CAAC,IAAI,CAAC,CAAA;QACX,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAA;QACvB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,aAAa,CAAA;QAC3C,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAA;IACnC,CAAC;CACF;AAlBC;IADC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,+BAA+B,CAAC,CAAC,OAAO,CAAC,oCAAoC,CAAC,CAAC;;2CAC7F;AAGnB;IADC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,oCAAoC,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;;8CACzE;AAOtB;IALC,MAAM,CACL,GAAG,CAAC,MAAM,EAAE;SACT,WAAW,CAAC,+BAA+B,CAAC;SAC5C,OAAO,CAAC,kDAAkD,CAAC,CAC/D;;gDACuB;AAU1B,MAAM,cAAc,GAAG,EAAE,OAAO,EAAE,oCAAoC,EAAE,CAAA;AAExE,MAAM,cAAe,SAAQ,aAAa;IAWxC,sBAAsB;IAEtB,YAAY,IAAmB,EAAE,OAAgB,EAAE,OAAqB;QACtE,KAAK,CAAC,IAAI,CAAC,CAAA;QACX,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,aAAa,CAAA;IACrD,CAAC;CACF;AAZC;IALC,MAAM,CACL,yBAAgB,CAAC,qBAAY,EAAE;SAC5B,WAAW,CAAC,0EAA0E,CAAC;SACvF,OAAO,CAAC,cAAc,CAAC,CACzB,CAAC;;+CACwB;AAG5B;IADC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,qCAAqC,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;;+CAC1E;AAWxB;;;GAGG;AACH,MAAa,mBAAoB,SAAQ,oBAAoB;IAyC3D,YACE,MAAc,EACd,WAAwB,EACxB,aAA6B;QAE7B,KAAK,EAAE,CAAA;QAEP,MAAM,KAAK,GAAG,IAAI,CAAA;QAElB,IAAI,CAAC,WAAW,GAAG,IAAI,kBAAkB,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;QAElE,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CACV,CAAC,MAAM,CAAC,IAAI,EAAE,GAAS,EAAE;gBAC/D,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;gBAClD,OAAO,IAAI,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;YACzC,CAAC,CAAA,CAAC,CACH,CAAC,CAAA;QAEF,MAAM,YAAY,GAAG,gBAAO,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;QAEvF,IAAI,CAAC,QAAQ,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACP,CAAC,IAAI,EAAE,GAAS,EAAE;gBACzD,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;gBAC7C,MAAM,OAAO,qBACR,OAAO,CAAC,MAAM,CAAC,OAAO,EACtB,MAAM,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,OAAO,EAAE,CAAC,CACvD,CAAA;gBACD,OAAO,IAAI,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;YACpD,CAAC,CAAA,CAAC,CACH,CAAC,CAAA;QAEF,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAqB,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;QAEzF,4CAA4C;QAE5C,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS,CAAA;IACxC,CAAC;CACF;AAzEC;IAJC,MAAM,CACL,kBAAkB,CAAC,SAAS,EAAE;SAC3B,WAAW,CAAC,mEAAmE,CAAC,CACpF;8BACmB,kBAAkB;wDAAA;AAOtC;IALC,MAAM,CACL,yBAAgB,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC;SACxC,WAAW,CAAC,qEAAqE,CAAC;SAClF,OAAO,CAAC,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,oCAAoC,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,CAAC,CACrG;8BACe,GAAG;oDAAsC;AAOzD;IALC,MAAM,CACL,yBAAgB,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC;SACzC,WAAW,CAAC,sEAAsE,CAAC;SACnF,OAAO,CAAC,EAAE,YAAY,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,CAAC,CACnF;8BACgB,GAAG;qDAAuC;AAO3D;IALC,MAAM,CACL,yBAAgB,CAAC,kCAAwB,CAAC;SACvC,WAAW,CAAC,yFAAyF,CAAC;SACtG,OAAO,CAAC,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,EAAE,EAAE,CAAC,CACrF;8BACiB,GAAG;sDAAkB;AAavC;IALC,MAAM,CACL,yBAAgB,CAAC,qBAAY,EAAE,CAAC;SAC7B,WAAW,CAAC,8DAA8D,CAAC;SAC3E,OAAO,CAAC,EAAE,WAAW,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,gCAAgC,EAAE,CAAC,CAC1G;;sDAC6B;AAvChC,kDA8EC;AAED,oDAAoD;AACpD,8CAA8C;AAC9C,cAAc;AACd,MAAM;AAEN,4CAA4C;AAC5C,0DAA0D;AAC1D,gDAAgD;AAChD,MAAM;AACN,IAAI","file":"config/config-context.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { isString, flatten } from \"lodash\"\nimport { Module } from \"../types/module\"\nimport { PrimitiveMap, isPrimitive, Primitive, joiIdentifierMap, joiStringMap, joiPrimitive } from \"./common\"\nimport { Provider, Environment, providerConfigBaseSchema } from \"./project\"\nimport { ModuleConfig } from \"./module\"\nimport { ConfigurationError } from \"../exceptions\"\nimport { Service } from \"../types/service\"\nimport { resolveTemplateString } from \"../template-string\"\nimport * as Joi from \"joi\"\nimport { Garden } from \"../garden\"\n\nexport type ContextKey = string[]\n\nexport interface ContextResolveParams {\n  key: ContextKey\n  nodePath: ContextKey\n  // a list of previously resolved paths, used to detect circular references\n  stack?: string[]\n}\n\nexport function schema(joiSchema: Joi.Schema) {\n  return (target, propName) => {\n    target.constructor._schemas = { ...target.constructor._schemas || {}, [propName]: joiSchema }\n  }\n}\n\n// Note: we're using classes here to be able to use decorators to describe each context node and key\nexport abstract class ConfigContext {\n  private readonly _rootContext: ConfigContext\n  private readonly _resolvedValues: { [path: string]: string }\n\n  constructor(rootContext?: ConfigContext) {\n    this._rootContext = rootContext || this\n    this._resolvedValues = {}\n  }\n\n  static getSchema() {\n    const schemas = (<any>this)._schemas\n    return Joi.object().keys(schemas).required()\n  }\n\n  async resolve({ key, nodePath, stack }: ContextResolveParams): Promise<Primitive> {\n    const path = key.join(\".\")\n    const fullPath = nodePath.concat(key).join(\".\")\n\n    // if the key has previously been resolved, return it directly\n    const resolved = this._resolvedValues[path]\n\n    if (resolved) {\n      return resolved\n    }\n\n    stack = [...stack || []]\n\n    if (stack.includes(fullPath)) {\n      throw new ConfigurationError(\n        `Circular reference detected when resolving key ${path} (${stack.join(\" -> \")})`,\n        {\n          nodePath,\n          fullPath,\n          stack,\n        },\n      )\n    }\n\n    // keep track of which resolvers have been called, in order to detect circular references\n    let value: any = this\n\n    for (let p = 0; p < key.length; p++) {\n      const nextKey = key[p]\n      const lookupPath = key.slice(0, p + 1)\n      const remainder = key.slice(p + 1)\n      const nestedNodePath = nodePath.concat(lookupPath)\n      const stackEntry = nestedNodePath.join(\".\")\n\n      if (nextKey.startsWith(\"_\")) {\n        value = undefined\n      } else {\n        value = value instanceof Map ? value.get(nextKey) : value[nextKey]\n      }\n\n      if (typeof value === \"function\") {\n        // call the function to resolve the value, then continue\n        value = await value()\n      }\n\n      // handle nested contexts\n      if (value instanceof ConfigContext) {\n        const nestedKey = remainder\n        stack.push(stackEntry)\n        value = await value.resolve({ key: nestedKey, nodePath: nestedNodePath, stack })\n        break\n      }\n\n      // handle templated strings in context variables\n      if (isString(value)) {\n        stack.push(stackEntry)\n        value = await resolveTemplateString(value, this._rootContext, stack)\n      }\n\n      if (value === undefined) {\n        break\n      }\n    }\n\n    if (value === undefined) {\n      throw new ConfigurationError(`Could not find key: ${path}`, {\n        nodePath,\n        fullPath,\n        stack,\n      })\n    }\n\n    if (!isPrimitive(value)) {\n      throw new ConfigurationError(\n        `Config value at ${path} exists but is not a primitive (string, number or boolean)`,\n        {\n          value,\n          path,\n          fullPath,\n          context,\n        },\n      )\n    }\n\n    this._resolvedValues[path] = value\n    return value\n  }\n}\n\nclass LocalContext extends ConfigContext {\n  @schema(\n    joiStringMap(Joi.string()).description(\n      \"A map of all local environment variables (see https://nodejs.org/api/process.html#process_process_env).\",\n    ),\n  )\n  public env: typeof process.env\n\n  @schema(\n    Joi.string()\n      .description(\n        \"A string indicating the platform that the framework is running on \" +\n        \"(see https://nodejs.org/api/process.html#process_process_platform)\",\n      )\n      .example(\"posix\"),\n  )\n  public platform: string\n\n  constructor(root: ConfigContext) {\n    super(root)\n    this.env = process.env\n    this.platform = process.platform\n  }\n}\n\n/**\n * This context is available for template strings under the `project` key in configuration files.\n */\nexport class ProjectConfigContext extends ConfigContext {\n  @schema(LocalContext.getSchema())\n  public local: LocalContext\n\n  constructor() {\n    super()\n    this.local = new LocalContext(this)\n  }\n}\n\nclass EnvironmentContext extends ConfigContext {\n  @schema(\n    Joi.string()\n      .description(\"The name of the environment Garden is running against.\")\n      .example(\"local\"),\n  )\n  public name: string\n\n  constructor(root: ConfigContext, name: string) {\n    super(root)\n    this.name = name\n  }\n}\n\nconst exampleVersion = \"v17ad4cb3fd\"\n\nclass ModuleContext extends ConfigContext {\n  @schema(Joi.string().description(\"The local path of the module.\").example(\"/home/me/code/my-project/my-module\"))\n  public path: string\n\n  @schema(Joi.string().description(\"The current version of the module.\").example(exampleVersion))\n  public version: string\n\n  @schema(\n    Joi.string()\n      .description(\"The build path of the module.\")\n      .example(\"/home/me/code/my-project/.garden/build/my-module\"),\n  )\n  public buildPath: string\n\n  constructor(root: ConfigContext, module: Module) {\n    super(root)\n    this.path = module.path\n    this.version = module.version.versionString\n    this.buildPath = module.buildPath\n  }\n}\n\nconst exampleOutputs = { ingress: \"http://my-service/path/to/endpoint\" }\n\nclass ServiceContext extends ConfigContext {\n  @schema(\n    joiIdentifierMap(joiPrimitive()\n      .description(\"The outputs defined by the service (see individual plugins for details).\")\n      .example(exampleOutputs),\n    ))\n  public outputs: PrimitiveMap\n\n  @schema(Joi.string().description(\"The current version of the service.\").example(exampleVersion))\n  public version: string\n\n  // TODO: add ingresses\n\n  constructor(root: ConfigContext, service: Service, outputs: PrimitiveMap) {\n    super(root)\n    this.outputs = outputs\n    this.version = service.module.version.versionString\n  }\n}\n\n/**\n * This context is available for template strings under the `module` key in configuration files.\n * It is a superset of the context available under the `project` key.\n */\nexport class ModuleConfigContext extends ProjectConfigContext {\n  @schema(\n    EnvironmentContext.getSchema()\n      .description(\"Information about the environment that Garden is running against.\"),\n  )\n  public environment: EnvironmentContext\n\n  @schema(\n    joiIdentifierMap(ModuleContext.getSchema())\n      .description(\"Retrieve information about modules that are defined in the project.\")\n      .example({ \"my-module\": { path: \"/home/me/code/my-project/my-module\", version: exampleVersion } }),\n  )\n  public modules: Map<string, () => Promise<ModuleContext>>\n\n  @schema(\n    joiIdentifierMap(ServiceContext.getSchema())\n      .description(\"Retrieve information about services that are defined in the project.\")\n      .example({ \"my-service\": { outputs: exampleOutputs, version: exampleVersion } }),\n  )\n  public services: Map<string, () => Promise<ServiceContext>>\n\n  @schema(\n    joiIdentifierMap(providerConfigBaseSchema)\n      .description(\"A map of all configured plugins/providers for this environment and their configuration.\")\n      .example({ kubernetes: { name: \"local-kubernetes\", context: \"my-kube-context\" } }),\n  )\n  public providers: Map<string, Provider>\n\n  // NOTE: This has some negative performance implications and may not be something we want to support,\n  //       so I'm disabling this feature for now.\n  //\n  // @description(\"Use this to look up values that are configured in the current environment.\")\n  // public config: RemoteConfigContext\n\n  @schema(\n    joiIdentifierMap(joiPrimitive())\n      .description(\"A map of all variables defined in the project configuration.\")\n      .example({ \"team-name\": \"bananaramallama\", \"some-service-endpoint\": \"https://someservice.com/api/v2\" }),\n  )\n  public variables: PrimitiveMap\n\n  constructor(\n    garden: Garden,\n    environment: Environment,\n    moduleConfigs: ModuleConfig[],\n  ) {\n    super()\n\n    const _this = this\n\n    this.environment = new EnvironmentContext(_this, environment.name)\n\n    this.modules = new Map(moduleConfigs.map((config) =>\n      <[string, () => Promise<ModuleContext>]>[config.name, async () => {\n        const module = await garden.getModule(config.name)\n        return new ModuleContext(_this, module)\n      }],\n    ))\n\n    const serviceNames = flatten(moduleConfigs.map(m => m.serviceConfigs)).map(s => s.name)\n\n    this.services = new Map(serviceNames.map((name) =>\n      <[string, () => Promise<ServiceContext>]>[name, async () => {\n        const service = await garden.getService(name)\n        const outputs = {\n          ...service.config.outputs,\n          ...await garden.actions.getServiceOutputs({ service }),\n        }\n        return new ServiceContext(_this, service, outputs)\n      }],\n    ))\n\n    this.providers = new Map(environment.providers.map(p => <[string, Provider]>[p.name, p]))\n\n    // this.config = new SecretsContextNode(ctx)\n\n    this.variables = environment.variables\n  }\n}\n\n// class RemoteConfigContext extends ConfigContext {\n//   constructor(private ctx: PluginContext) {\n//     super()\n//   }\n\n//   async resolve({ key }: ResolveParams) {\n//     const { value } = await this.ctx.getSecret({ key })\n//     return value === null ? undefined : value\n//   }\n// }\n"]} diff --git a/garden-service/build/config/module.d.ts b/garden-service/build/config/module.d.ts new file mode 100644 index 00000000000..fafe81be637 --- /dev/null +++ b/garden-service/build/config/module.d.ts @@ -0,0 +1,39 @@ +import * as Joi from "joi"; +import { ServiceConfig, ServiceSpec } from "./service"; +import { PrimitiveMap } from "./common"; +import { TestConfig, TestSpec } from "./test"; +export interface BuildCopySpec { + source: string; + target: string; +} +export interface BuildDependencyConfig { + name: string; + plugin?: string; + copy: BuildCopySpec[]; +} +export declare const buildDependencySchema: Joi.ObjectSchema; +export interface BuildConfig { + command: string[]; + dependencies: BuildDependencyConfig[]; +} +export interface ModuleSpec { +} +export interface BaseModuleSpec { + allowPublish: boolean; + build: BuildConfig; + description?: string; + name: string; + path: string; + type: string; + variables: PrimitiveMap; + repositoryUrl?: string; +} +export declare const baseModuleSpecSchema: Joi.ObjectSchema; +export interface ModuleConfig extends BaseModuleSpec { + plugin?: string; + serviceConfigs: ServiceConfig[]; + testConfigs: TestConfig[]; + spec: M; +} +export declare const moduleConfigSchema: Joi.ObjectSchema; +//# sourceMappingURL=module.d.ts.map \ No newline at end of file diff --git a/garden-service/build/config/module.js b/garden-service/build/config/module.js new file mode 100644 index 00000000000..51ccf8d6cbe --- /dev/null +++ b/garden-service/build/config/module.js @@ -0,0 +1,76 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const common_1 = require("./common"); +// TODO: allow : delimited string (e.g. some.file:some-dir/) +const copySchema = Joi.object() + .keys({ + // TODO: allow array of strings here + // TODO: disallow paths outside of the module root + source: Joi.string().uri({ relativeOnly: true }).required() + .description("POSIX-style path or filename of the directory or file(s) to copy to the target."), + target: Joi.string().uri({ relativeOnly: true }).default("") + .description("POSIX-style path or filename to copy the directory or file(s) to (defaults to same as source path)."), +}); +exports.buildDependencySchema = Joi.object().keys({ + name: common_1.joiIdentifier().required() + .description("Module name to build ahead of this module"), + plugin: common_1.joiIdentifier() + .meta({ internal: true }) + .description("The name of plugin that provides the build dependency."), + copy: common_1.joiArray(copySchema) + .description("Specify one or more files or directories to copy from the built dependency to this module."), +}); +exports.baseModuleSpecSchema = Joi.object() + .keys({ + type: common_1.joiIdentifier() + .required() + .description("The type of this module.") + .example("container"), + name: common_1.joiIdentifier() + .required() + .description("The name of this module.") + .example("my-sweet-module"), + description: Joi.string(), + repositoryUrl: common_1.joiRepositoryUrl() + .description("A remote repository URL to fetch the module from. Garden will read the garden.yml config" + + " from the local module." + + " Currently only supports git servers."), + variables: common_1.joiVariables() + .description("Variables that this module can reference and expose as environment variables.") + .example({ "my-variable": "some-value" }), + allowPublish: Joi.boolean() + .default(true) + .description("Set to false to disable pushing this module to remote registries."), + build: Joi.object().keys({ + // TODO: move this out of base spec + command: common_1.joiArray(Joi.string()) + .description("The command to run inside the module directory to perform the build.") + .example(["npm", "run", "build"]), + dependencies: common_1.joiArray(exports.buildDependencySchema) + .description("A list of modules that must be built before this module is built.") + .example([{ name: "some-other-module-name" }]), + }) + .default(() => ({ dependencies: [] }), "{}") + .description("Specify how to build the module. Note that plugins may specify additional keys on this object."), +}) + .required() + .unknown(true) + .description("Configure a module whose sources are located in this directory.") + .meta({ extendable: true }); +exports.moduleConfigSchema = exports.baseModuleSpecSchema + .keys({ + spec: Joi.object() + .meta({ extendable: true }) + .description("The module spec, as defined by the provider plugin."), +}) + .description("The configuration for a module."); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["config/module.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAEH,2BAA0B;AAE1B,qCAMiB;AAQjB,4DAA4D;AAC5D,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,EAAE;KAC5B,IAAI,CAAC;IACJ,oCAAoC;IACpC,kDAAkD;IAClD,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,CAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE;SAC7D,WAAW,CAAC,iFAAiF,CAAC;IACjG,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,CAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;SAC9D,WAAW,CACV,qGAAqG,CACtG;CACJ,CAAC,CAAA;AAQS,QAAA,qBAAqB,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC;IACrD,IAAI,EAAE,sBAAa,EAAE,CAAC,QAAQ,EAAE;SAC7B,WAAW,CAAC,2CAA2C,CAAC;IAC3D,MAAM,EAAE,sBAAa,EAAE;SACpB,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;SACxB,WAAW,CAAC,wDAAwD,CAAC;IACxE,IAAI,EAAE,iBAAQ,CAAC,UAAU,CAAC;SACvB,WAAW,CAAC,4FAA4F,CAAC;CAC7G,CAAC,CAAA;AAoBW,QAAA,oBAAoB,GAAG,GAAG,CAAC,MAAM,EAAE;KAC7C,IAAI,CAAC;IACJ,IAAI,EAAE,sBAAa,EAAE;SAClB,QAAQ,EAAE;SACV,WAAW,CAAC,0BAA0B,CAAC;SACvC,OAAO,CAAC,WAAW,CAAC;IACvB,IAAI,EAAE,sBAAa,EAAE;SAClB,QAAQ,EAAE;SACV,WAAW,CAAC,0BAA0B,CAAC;SACvC,OAAO,CAAC,iBAAiB,CAAC;IAC7B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE;IACzB,aAAa,EAAE,yBAAgB,EAAE;SAC9B,WAAW,CACV,0FAA0F;QAC1F,yBAAyB;QACzB,uCAAuC,CACxC;IACH,SAAS,EAAE,qBAAY,EAAE;SACtB,WAAW,CAAC,+EAA+E,CAAC;SAC5F,OAAO,CAAC,EAAE,aAAa,EAAE,YAAY,EAAE,CAAC;IAC3C,YAAY,EAAE,GAAG,CAAC,OAAO,EAAE;SACxB,OAAO,CAAC,IAAI,CAAC;SACb,WAAW,CAAC,mEAAmE,CAAC;IACnF,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC;QACvB,mCAAmC;QACnC,OAAO,EAAE,iBAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC;aAC5B,WAAW,CAAC,sEAAsE,CAAC;aACnF,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QACnC,YAAY,EAAE,iBAAQ,CAAC,6BAAqB,CAAC;aAC1C,WAAW,CAAC,mEAAmE,CAAC;aAChF,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,wBAAwB,EAAE,CAAC,CAAC;KACjD,CAAC;SACC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC;SAC3C,WAAW,CAAC,gGAAgG,CAAC;CACjH,CAAC;KACD,QAAQ,EAAE;KACV,OAAO,CAAC,IAAI,CAAC;KACb,WAAW,CAAC,iEAAiE,CAAC;KAC9E,IAAI,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAA;AAehB,QAAA,kBAAkB,GAAG,4BAAoB;KACnD,IAAI,CAAC;IACJ,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE;SACf,IAAI,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;SAC1B,WAAW,CAAC,qDAAqD,CAAC;CACtE,CAAC;KACD,WAAW,CAAC,iCAAiC,CAAC,CAAA","file":"config/module.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Joi from \"joi\"\nimport { ServiceConfig, ServiceSpec } from \"./service\"\nimport {\n  joiArray,\n  joiIdentifier,\n  joiVariables,\n  PrimitiveMap,\n  joiRepositoryUrl,\n} from \"./common\"\nimport { TestConfig, TestSpec } from \"./test\"\n\nexport interface BuildCopySpec {\n  source: string\n  target: string\n}\n\n// TODO: allow : delimited string (e.g. some.file:some-dir/)\nconst copySchema = Joi.object()\n  .keys({\n    // TODO: allow array of strings here\n    // TODO: disallow paths outside of the module root\n    source: Joi.string().uri(<any>{ relativeOnly: true }).required()\n      .description(\"POSIX-style path or filename of the directory or file(s) to copy to the target.\"),\n    target: Joi.string().uri(<any>{ relativeOnly: true }).default(\"\")\n      .description(\n        \"POSIX-style path or filename to copy the directory or file(s) to (defaults to same as source path).\",\n      ),\n  })\n\nexport interface BuildDependencyConfig {\n  name: string\n  plugin?: string\n  copy: BuildCopySpec[]\n}\n\nexport const buildDependencySchema = Joi.object().keys({\n  name: joiIdentifier().required()\n    .description(\"Module name to build ahead of this module\"),\n  plugin: joiIdentifier()\n    .meta({ internal: true })\n    .description(\"The name of plugin that provides the build dependency.\"),\n  copy: joiArray(copySchema)\n    .description(\"Specify one or more files or directories to copy from the built dependency to this module.\"),\n})\n\nexport interface BuildConfig {\n  command: string[],\n  dependencies: BuildDependencyConfig[],\n}\n\nexport interface ModuleSpec { }\n\nexport interface BaseModuleSpec {\n  allowPublish: boolean\n  build: BuildConfig\n  description?: string\n  name: string\n  path: string\n  type: string\n  variables: PrimitiveMap\n  repositoryUrl?: string\n}\n\nexport const baseModuleSpecSchema = Joi.object()\n  .keys({\n    type: joiIdentifier()\n      .required()\n      .description(\"The type of this module.\")\n      .example(\"container\"),\n    name: joiIdentifier()\n      .required()\n      .description(\"The name of this module.\")\n      .example(\"my-sweet-module\"),\n    description: Joi.string(),\n    repositoryUrl: joiRepositoryUrl()\n      .description(\n        \"A remote repository URL to fetch the module from. Garden will read the garden.yml config\" +\n        \" from the local module.\" +\n        \" Currently only supports git servers.\",\n      ),\n    variables: joiVariables()\n      .description(\"Variables that this module can reference and expose as environment variables.\")\n      .example({ \"my-variable\": \"some-value\" }),\n    allowPublish: Joi.boolean()\n      .default(true)\n      .description(\"Set to false to disable pushing this module to remote registries.\"),\n    build: Joi.object().keys({\n      // TODO: move this out of base spec\n      command: joiArray(Joi.string())\n        .description(\"The command to run inside the module directory to perform the build.\")\n        .example([\"npm\", \"run\", \"build\"]),\n      dependencies: joiArray(buildDependencySchema)\n        .description(\"A list of modules that must be built before this module is built.\")\n        .example([{ name: \"some-other-module-name\" }]),\n    })\n      .default(() => ({ dependencies: [] }), \"{}\")\n      .description(\"Specify how to build the module. Note that plugins may specify additional keys on this object.\"),\n  })\n  .required()\n  .unknown(true)\n  .description(\"Configure a module whose sources are located in this directory.\")\n  .meta({ extendable: true })\n\nexport interface ModuleConfig\n  <M extends ModuleSpec = any, S extends ServiceSpec = any, T extends TestSpec = any>\n  extends BaseModuleSpec {\n\n  plugin?: string   // used to identify modules that are bundled as part of a plugin\n\n  serviceConfigs: ServiceConfig<S>[]\n  testConfigs: TestConfig<T>[]\n\n  // Plugins can add custom fields that are kept here\n  spec: M\n}\n\nexport const moduleConfigSchema = baseModuleSpecSchema\n  .keys({\n    spec: Joi.object()\n      .meta({ extendable: true })\n      .description(\"The module spec, as defined by the provider plugin.\"),\n  })\n  .description(\"The configuration for a module.\")\n"]} diff --git a/garden-service/build/config/project.d.ts b/garden-service/build/config/project.d.ts new file mode 100644 index 00000000000..301a2536c33 --- /dev/null +++ b/garden-service/build/config/project.d.ts @@ -0,0 +1,43 @@ +import * as Joi from "joi"; +import { Primitive } from "./common"; +export interface ProviderConfig { + name: string; + [key: string]: any; +} +export declare const providerConfigBaseSchema: Joi.ObjectSchema; +export interface Provider { + name: string; + config: T; +} +export interface CommonEnvironmentConfig { + providers: ProviderConfig[]; + variables: { + [key: string]: Primitive; + }; +} +export declare const environmentConfigSchema: Joi.ObjectSchema; +export interface Environment extends CommonEnvironmentConfig { + name: string; +} +export declare const environmentSchema: Joi.ObjectSchema; +export interface SourceConfig { + name: string; + repositoryUrl: string; +} +export declare const projectSourceSchema: Joi.ObjectSchema; +export declare const projectSourcesSchema: Joi.ArraySchema; +export interface ProjectConfig { + name: string; + defaultEnvironment: string; + environmentDefaults: CommonEnvironmentConfig; + environments: Environment[]; + sources?: SourceConfig[]; +} +export declare const defaultProviders: { + name: string; +}[]; +export declare const defaultEnvironments: Environment[]; +export declare const projectNameSchema: Joi.StringSchema; +export declare const projectSchema: Joi.ObjectSchema; +export declare const defaultProvider: Provider; +//# sourceMappingURL=project.d.ts.map \ No newline at end of file diff --git a/garden-service/build/config/project.js b/garden-service/build/config/project.js new file mode 100644 index 00000000000..c5e410c45a0 --- /dev/null +++ b/garden-service/build/config/project.js @@ -0,0 +1,94 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const js_yaml_1 = require("js-yaml"); +const common_1 = require("./common"); +exports.providerConfigBaseSchema = Joi.object() + .keys({ + name: common_1.joiIdentifier().required() + .description("The name of the provider plugin to configure.") + .example("local-kubernetes"), +}) + .unknown(true) + .meta({ extendable: true }); +exports.environmentConfigSchema = Joi.object() + .keys({ + providers: common_1.joiArray(exports.providerConfigBaseSchema) + .unique("name") + .description("A list of providers that should be used for this environment, and their configuration. " + + "Please refer to individual plugins/providers for details on how to configure them."), + variables: common_1.joiVariables() + .description("A key/value map of variables that modules can reference when using this environment."), +}); +exports.environmentSchema = exports.environmentConfigSchema + .keys({ + name: Joi.string() + .required() + .description("The name of the current environment."), +}); +exports.projectSourceSchema = Joi.object() + .keys({ + name: common_1.joiIdentifier() + .required() + .description("The name of the source to import"), + repositoryUrl: common_1.joiRepositoryUrl() + .required(), +}); +exports.projectSourcesSchema = common_1.joiArray(exports.projectSourceSchema) + .unique("name") + .description("A list of remote sources to import into project"); +exports.defaultProviders = [ + { name: "container" }, +]; +exports.defaultEnvironments = [ + { + name: "local", + providers: [ + { + name: "local-kubernetes", + }, + ], + variables: {}, + }, +]; +const environmentDefaults = { + providers: [], + variables: {}, +}; +exports.projectNameSchema = common_1.joiIdentifier() + .required() + .description("The name of the project.") + .example("my-sweet-project"); +exports.projectSchema = Joi.object() + .keys({ + name: exports.projectNameSchema, + defaultEnvironment: Joi.string() + .default("", "") + .description("The default environment to use when calling commands without the `--env` parameter."), + environmentDefaults: exports.environmentConfigSchema + .default(() => environmentDefaults, js_yaml_1.safeDump(environmentDefaults)) + .example(environmentDefaults) + .description("Default environment settings, that are inherited (but can be overridden) by each configured environment"), + environments: common_1.joiArray(exports.environmentConfigSchema.keys({ name: common_1.joiIdentifier().required() })) + .unique("name") + .default(() => (Object.assign({}, exports.defaultEnvironments)), js_yaml_1.safeDump(exports.defaultEnvironments)) + .description("A list of environments to configure for the project.") + .example(exports.defaultEnvironments), + sources: exports.projectSourcesSchema, +}) + .required() + .description("The configuration for a Garden project. This should be specified in the garden.yml file in your project root."); +// this is used for default handlers in the action handler +exports.defaultProvider = { + name: "_default", + config: {}, +}; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["config/project.ts"],"names":[],"mappings":"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","file":"config/project.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Joi from \"joi\"\nimport { safeDump } from \"js-yaml\"\nimport {\n  joiArray,\n  joiIdentifier,\n  joiVariables,\n  Primitive,\n  joiRepositoryUrl,\n} from \"./common\"\n\nexport interface ProviderConfig {\n  name: string\n  [key: string]: any\n}\n\nexport const providerConfigBaseSchema = Joi.object()\n  .keys({\n    name: joiIdentifier().required()\n      .description(\"The name of the provider plugin to configure.\")\n      .example(\"local-kubernetes\"),\n  })\n  .unknown(true)\n  .meta({ extendable: true })\n\nexport interface Provider<T extends ProviderConfig = any> {\n  name: string\n  config: T\n}\n\nexport interface CommonEnvironmentConfig {\n  providers: ProviderConfig[]  // further validated by each plugin\n  variables: { [key: string]: Primitive }\n}\n\nexport const environmentConfigSchema = Joi.object()\n  .keys({\n    providers: joiArray(providerConfigBaseSchema)\n      .unique(\"name\")\n      .description(\n        \"A list of providers that should be used for this environment, and their configuration. \" +\n        \"Please refer to individual plugins/providers for details on how to configure them.\",\n      ),\n    variables: joiVariables()\n      .description(\"A key/value map of variables that modules can reference when using this environment.\"),\n  })\n\nexport interface Environment extends CommonEnvironmentConfig {\n  name: string\n}\n\nexport const environmentSchema = environmentConfigSchema\n  .keys({\n    name: Joi.string()\n      .required()\n      .description(\"The name of the current environment.\"),\n  })\n\nexport interface SourceConfig {\n  name: string\n  repositoryUrl: string\n}\n\nexport const projectSourceSchema = Joi.object()\n  .keys({\n    name: joiIdentifier()\n      .required()\n      .description(\"The name of the source to import\"),\n    repositoryUrl: joiRepositoryUrl()\n      .required(),\n  })\n\nexport const projectSourcesSchema = joiArray(projectSourceSchema)\n  .unique(\"name\")\n  .description(\"A list of remote sources to import into project\")\n\nexport interface ProjectConfig {\n  name: string\n  defaultEnvironment: string\n  environmentDefaults: CommonEnvironmentConfig\n  environments: Environment[]\n  sources?: SourceConfig[]\n}\n\nexport const defaultProviders = [\n  { name: \"container\" },\n]\n\nexport const defaultEnvironments: Environment[] = [\n  {\n    name: \"local\",\n    providers: [\n      {\n        name: \"local-kubernetes\",\n      },\n    ],\n    variables: {},\n  },\n]\n\nconst environmentDefaults = {\n  providers: [],\n  variables: {},\n}\n\nexport const projectNameSchema = joiIdentifier()\n  .required()\n  .description(\"The name of the project.\")\n  .example(\"my-sweet-project\")\n\nexport const projectSchema = Joi.object()\n  .keys({\n    name: projectNameSchema,\n    defaultEnvironment: Joi.string()\n      .default(\"\", \"<first specified environment>\")\n      .description(\"The default environment to use when calling commands without the `--env` parameter.\"),\n    environmentDefaults: environmentConfigSchema\n      .default(() => environmentDefaults, safeDump(environmentDefaults))\n      .example(environmentDefaults)\n      .description(\n        \"Default environment settings, that are inherited (but can be overridden) by each configured environment\",\n      ),\n    environments: joiArray(environmentConfigSchema.keys({ name: joiIdentifier().required() }))\n      .unique(\"name\")\n      .default(() => ({ ...defaultEnvironments }), safeDump(defaultEnvironments))\n      .description(\"A list of environments to configure for the project.\")\n      .example(defaultEnvironments),\n    sources: projectSourcesSchema,\n  })\n  .required()\n  .description(\n    \"The configuration for a Garden project. This should be specified in the garden.yml file in your project root.\",\n  )\n\n// this is used for default handlers in the action handler\nexport const defaultProvider: Provider = {\n  name: \"_default\",\n  config: {},\n}\n"]} diff --git a/garden-service/build/config/service.d.ts b/garden-service/build/config/service.d.ts new file mode 100644 index 00000000000..5d73ee3600e --- /dev/null +++ b/garden-service/build/config/service.d.ts @@ -0,0 +1,16 @@ +import * as Joi from "joi"; +import { PrimitiveMap } from "./common"; +export interface ServiceSpec { +} +export interface BaseServiceSpec extends ServiceSpec { + name: string; + dependencies: string[]; + outputs: PrimitiveMap; +} +export declare const serviceOutputsSchema: Joi.ObjectSchema; +export declare const baseServiceSchema: Joi.ObjectSchema; +export interface ServiceConfig extends BaseServiceSpec { + spec: T; +} +export declare const serviceConfigSchema: Joi.ObjectSchema; +//# sourceMappingURL=service.d.ts.map \ No newline at end of file diff --git a/garden-service/build/config/service.js b/garden-service/build/config/service.js new file mode 100644 index 00000000000..8c8a8e3f1ac --- /dev/null +++ b/garden-service/build/config/service.js @@ -0,0 +1,31 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const common_1 = require("./common"); +exports.serviceOutputsSchema = common_1.joiIdentifierMap(common_1.joiPrimitive()); +exports.baseServiceSchema = Joi.object() + .keys({ + name: common_1.joiIdentifier().required(), + dependencies: common_1.joiArray(common_1.joiIdentifier()) + .description("The names of services that this service depends on at runtime."), + outputs: exports.serviceOutputsSchema, +}) + .unknown(true) + .meta({ extendable: true }) + .description("The required attributes of a service. This is generally further defined by plugins."); +exports.serviceConfigSchema = exports.baseServiceSchema + .keys({ + spec: Joi.object() + .meta({ extendable: true }) + .description("The service's specification, as defined by its provider plugin."), +}) + .description("The configuration for a module's service."); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/config/test.d.ts b/garden-service/build/config/test.d.ts new file mode 100644 index 00000000000..28bc91250df --- /dev/null +++ b/garden-service/build/config/test.d.ts @@ -0,0 +1,14 @@ +import * as Joi from "joi"; +export interface TestSpec { +} +export interface BaseTestSpec extends TestSpec { + name: string; + dependencies: string[]; + timeout: number | null; +} +export declare const baseTestSpecSchema: Joi.ObjectSchema; +export interface TestConfig extends BaseTestSpec { + spec: T; +} +export declare const testConfigSchema: Joi.ObjectSchema; +//# sourceMappingURL=test.d.ts.map \ No newline at end of file diff --git a/garden-service/build/config/test.js b/garden-service/build/config/test.js new file mode 100644 index 00000000000..558077bcbbd --- /dev/null +++ b/garden-service/build/config/test.js @@ -0,0 +1,33 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const common_1 = require("./common"); +exports.baseTestSpecSchema = Joi.object() + .keys({ + name: common_1.joiIdentifier() + .required() + .description("The name of the test."), + dependencies: common_1.joiArray(Joi.string()) + .description("The names of services that must be running before the test is run."), + timeout: Joi.number() + .allow(null) + .default(null) + .description("Maximum duration (in seconds) of the test run."), +}) + .description("Required configuration for module tests."); +exports.testConfigSchema = exports.baseTestSpecSchema + .keys({ + spec: Joi.object() + .meta({ extendable: true }) + .description("The configuration for the test, as specified by its module's provider."), +}) + .description("Configuration for a module test."); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/constants.d.ts b/garden-service/build/constants.d.ts new file mode 100644 index 00000000000..8aba905c424 --- /dev/null +++ b/garden-service/build/constants.d.ts @@ -0,0 +1,17 @@ +export declare const MODULE_CONFIG_FILENAME = "garden.yml"; +export declare const LOCAL_CONFIG_FILENAME = "local-config.yml"; +export declare const STATIC_DIR: string; +export declare const GARDEN_DIR_NAME = ".garden"; +export declare const LOGS_DIR: string; +export declare const ERROR_LOG_FILENAME = "error.log"; +export declare const PROJECT_SOURCES_DIR_NAME: string; +export declare const MODULE_SOURCES_DIR_NAME: string; +export declare const GARDEN_BUILD_VERSION_FILENAME = ".garden-build-version"; +export declare const GARDEN_VERSIONFILE_NAME = ".garden-version"; +export declare const DEFAULT_NAMESPACE = "default"; +export declare const DEFAULT_PORT_PROTOCOL = "TCP"; +export declare const GARDEN_ANNOTATION_PREFIX = "garden.io/"; +export declare const GARDEN_ANNOTATION_KEYS_SERVICE: string; +export declare const GARDEN_ANNOTATION_KEYS_VERSION: string; +export declare const DEFAULT_TEST_TIMEOUT: number; +//# sourceMappingURL=constants.d.ts.map \ No newline at end of file diff --git a/garden-service/build/constants.js b/garden-service/build/constants.js new file mode 100644 index 00000000000..f9df15fe68e --- /dev/null +++ b/garden-service/build/constants.js @@ -0,0 +1,28 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +exports.MODULE_CONFIG_FILENAME = "garden.yml"; +exports.LOCAL_CONFIG_FILENAME = "local-config.yml"; +exports.STATIC_DIR = path_1.resolve(__dirname, "..", "static"); +exports.GARDEN_DIR_NAME = ".garden"; +exports.LOGS_DIR = path_1.join(exports.GARDEN_DIR_NAME, "logs"); +exports.ERROR_LOG_FILENAME = "error.log"; +exports.PROJECT_SOURCES_DIR_NAME = path_1.join(exports.GARDEN_DIR_NAME, "sources", "project"); +exports.MODULE_SOURCES_DIR_NAME = path_1.join(exports.GARDEN_DIR_NAME, "sources", "module"); +exports.GARDEN_BUILD_VERSION_FILENAME = ".garden-build-version"; +exports.GARDEN_VERSIONFILE_NAME = ".garden-version"; +exports.DEFAULT_NAMESPACE = "default"; +exports.DEFAULT_PORT_PROTOCOL = "TCP"; +exports.GARDEN_ANNOTATION_PREFIX = "garden.io/"; +exports.GARDEN_ANNOTATION_KEYS_SERVICE = exports.GARDEN_ANNOTATION_PREFIX + "service"; +exports.GARDEN_ANNOTATION_KEYS_VERSION = exports.GARDEN_ANNOTATION_PREFIX + "version"; +exports.DEFAULT_TEST_TIMEOUT = 60 * 1000; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/docs/commands.d.ts b/garden-service/build/docs/commands.d.ts new file mode 100644 index 00000000000..e465c5d8946 --- /dev/null +++ b/garden-service/build/docs/commands.d.ts @@ -0,0 +1,2 @@ +export declare function generateCommandReferenceDocs(docsRoot: string): void; +//# sourceMappingURL=commands.d.ts.map \ No newline at end of file diff --git a/garden-service/build/docs/commands.js b/garden-service/build/docs/commands.js new file mode 100644 index 00000000000..ec8ff6bcd2c --- /dev/null +++ b/garden-service/build/docs/commands.js @@ -0,0 +1,37 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_1 = require("fs"); +const handlebars = require("handlebars"); +const path_1 = require("path"); +const cli_1 = require("../cli/cli"); +const commands_1 = require("../commands/commands"); +const lodash_1 = require("lodash"); +const base_1 = require("../commands/base"); +function generateCommandReferenceDocs(docsRoot) { + const referenceDir = path_1.resolve(docsRoot, "reference"); + const outputPath = path_1.resolve(referenceDir, "commands.md"); + const commands = lodash_1.flatten(commands_1.coreCommands.map(cmd => { + if (cmd.subCommands && cmd.subCommands.length) { + return cmd.subCommands.map(subCommandCls => new subCommandCls(cmd).describe()); + } + else { + return [cmd.describe()]; + } + })); + const globalOptions = base_1.describeParameters(cli_1.GLOBAL_OPTIONS); + const templatePath = path_1.resolve(__dirname, "templates", "commands.hbs"); + handlebars.registerPartial("argType", "{{#if choices}}{{#each choices}}`{{.}}` {{/each}}{{else}}{{type}}{{/if}}"); + const template = handlebars.compile(fs_1.readFileSync(templatePath).toString()); + const markdown = template({ commands, globalOptions }); + fs_1.writeFileSync(outputPath, markdown); +} +exports.generateCommandReferenceDocs = generateCommandReferenceDocs; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/docs/config.d.ts b/garden-service/build/docs/config.d.ts new file mode 100644 index 00000000000..f5b7e34964d --- /dev/null +++ b/garden-service/build/docs/config.d.ts @@ -0,0 +1,9 @@ +import * as Joi from "joi"; +interface RenderOpts { + level?: number; + required?: boolean; +} +export declare function renderSchemaDescription(description: Joi.Description, opts: RenderOpts): string; +export declare function generateConfigReferenceDocs(docsRoot: string): void; +export {}; +//# sourceMappingURL=config.d.ts.map \ No newline at end of file diff --git a/garden-service/build/docs/config.js b/garden-service/build/docs/config.js new file mode 100644 index 00000000000..a3344611ac6 --- /dev/null +++ b/garden-service/build/docs/config.js @@ -0,0 +1,145 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_1 = require("fs"); +const handlebars = require("handlebars"); +const js_yaml_1 = require("js-yaml"); +const linewrap = require("linewrap"); +const Joi = require("joi"); +const path_1 = require("path"); +const lodash_1 = require("lodash"); +const container_1 = require("../plugins/container"); +const generic_1 = require("../plugins/generic"); +const base_1 = require("../config/base"); +const module_1 = require("../config/module"); +const maxWidth = 100; +const builtInModuleTypes = [ + { name: "generic", schema: generic_1.genericModuleSpecSchema }, + { name: "container", schema: container_1.containerModuleSpecSchema }, +]; +function renderCommentDescription(description, width, { required }) { + const output = []; + const meta = []; + if (description.description) { + output.push(description.description); + } + if (description.examples && description.examples.length) { + const example = description.examples[0]; + if (description.type === "object" || description.type === "array") { + meta.push("Example:", ...indent(js_yaml_1.safeDump(example).trim().split("\n"), 1), ""); + } + else { + meta.push("Example: " + JSON.stringify(example), ""); + } + } + const allowOnly = lodash_1.get(description, "flags.allowOnly") === true; + if (required) { + const presenceRequired = lodash_1.get(description, "flags.presence") === "required"; + if (presenceRequired || allowOnly) { + meta.push("Required."); + } + else if (output.length) { + meta.push("Optional."); + } + } + if (allowOnly) { + meta.push("Allowed values: " + description.valids.map(v => JSON.stringify(v)).join(", ")); + } + if (meta.length > 0) { + output.push("", ...meta); + } + if (output.length === 0) { + return output; + } + const wrap = linewrap(width - 2, { whitespace: "line" }); + return wrap(output.join("\n")).split("\n").map(line => "# " + line); +} +function getDefaultValue(description) { + const defaultSpec = lodash_1.get(description, "flags.default"); + if (defaultSpec === undefined) { + return; + } + else if (defaultSpec && defaultSpec.function) { + return defaultSpec.function(); + } + else { + return defaultSpec; + } +} +function indent(lines, level) { + const prefix = lodash_1.padEnd("", level * 2, " "); + return lines.map(line => prefix + line); +} +function indentFromSecondLine(lines, level) { + return [...lines.slice(0, 1), ...indent(lines.slice(1), level)]; +} +function renderSchemaDescription(description, opts) { + const { level = 0 } = opts; + const indentSpaces = level * 2; + const descriptionWidth = maxWidth - indentSpaces - 2; + const output = []; + const defaultValue = getDefaultValue(description); + switch (description.type) { + case "object": + const children = Object.entries(description.children || {}); + if (!children.length) { + if (defaultValue) { + output.push("", ...js_yaml_1.safeDump(defaultValue).trim().split("\n")); + } + else { + output.push("{}"); + } + break; + } + output.push(""); + for (const [key, keyDescription] of children) { + if (lodash_1.get(keyDescription, "meta[0].internal")) { + continue; + } + output.push(...renderCommentDescription(keyDescription, descriptionWidth, opts), `${key}: ${renderSchemaDescription(keyDescription, Object.assign({}, opts, { level: level + 1 }))}`, ""); + } + output.pop(); + break; + case "array": + if (!description.items.length) { + output.push("[]"); + } + const itemDescription = description.items[0]; + output.push("", ...renderCommentDescription(itemDescription, descriptionWidth, opts), "- " + renderSchemaDescription(itemDescription, Object.assign({}, opts, { level: level + 1 })).trim(), ""); + break; + default: + output.push(defaultValue === undefined ? "" : defaultValue + ""); + } + // we don't indent the first line + return indentFromSecondLine(output, level) + .map(line => line.trimRight()) + .join("\n"); +} +exports.renderSchemaDescription = renderSchemaDescription; +function generateConfigReferenceDocs(docsRoot) { + const referenceDir = path_1.resolve(docsRoot, "reference"); + const outputPath = path_1.resolve(referenceDir, "config.md"); + const yaml = renderSchemaDescription(base_1.configSchema.describe(), { required: true }); + const moduleTypes = builtInModuleTypes.map(({ name, schema }) => { + schema = Joi.object().keys({ + module: module_1.baseModuleSpecSchema.concat(schema), + }); + return { + name, + yaml: renderSchemaDescription(schema.describe(), { required: true }), + }; + }); + const templatePath = path_1.resolve(__dirname, "templates", "config.hbs"); + const template = handlebars.compile(fs_1.readFileSync(templatePath).toString()); + const markdown = template({ yaml, moduleTypes }); + fs_1.writeFileSync(outputPath, markdown); +} +exports.generateConfigReferenceDocs = generateConfigReferenceDocs; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["docs/config.ts"],"names":[],"mappings":"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","file":"docs/config.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport {\n  readFileSync,\n  writeFileSync,\n} from \"fs\"\nimport * as handlebars from \"handlebars\"\nimport { safeDump } from \"js-yaml\"\nimport * as linewrap from \"linewrap\"\nimport * as Joi from \"joi\"\nimport { resolve } from \"path\"\nimport {\n  get,\n  padEnd,\n} from \"lodash\"\nimport { containerModuleSpecSchema } from \"../plugins/container\"\nimport { genericModuleSpecSchema } from \"../plugins/generic\"\nimport { configSchema } from \"../config/base\"\nimport { baseModuleSpecSchema } from \"../config/module\"\n\nconst maxWidth = 100\nconst builtInModuleTypes = [\n  { name: \"generic\", schema: genericModuleSpecSchema },\n  { name: \"container\", schema: containerModuleSpecSchema },\n]\n\ninterface RenderOpts {\n  level?: number\n  required?: boolean\n}\n\nfunction renderCommentDescription(description: Joi.Description, width: number, { required }: RenderOpts) {\n  const output: string[] = []\n  const meta: string[] = []\n\n  if (description.description) {\n    output.push(description.description)\n  }\n\n  if (description.examples && description.examples.length) {\n    const example = description.examples[0]\n\n    if (description.type === \"object\" || description.type === \"array\") {\n      meta.push(\"Example:\", ...indent(safeDump(example).trim().split(\"\\n\"), 1), \"\")\n    } else {\n      meta.push(\"Example: \" + JSON.stringify(example), \"\")\n    }\n  }\n\n  const allowOnly = get(description, \"flags.allowOnly\") === true\n\n  if (required) {\n    const presenceRequired = get(description, \"flags.presence\") === \"required\"\n\n    if (presenceRequired || allowOnly) {\n      meta.push(\"Required.\")\n    } else if (output.length) {\n      meta.push(\"Optional.\")\n    }\n  }\n\n  if (allowOnly) {\n    meta.push(\"Allowed values: \" + description.valids!.map(v => JSON.stringify(v)).join(\", \"))\n  }\n\n  if (meta.length > 0) {\n    output.push(\"\", ...meta)\n  }\n\n  if (output.length === 0) {\n    return output\n  }\n\n  const wrap = linewrap(width - 2, { whitespace: \"line\" })\n  return wrap(output.join(\"\\n\")).split(\"\\n\").map(line => \"# \" + line)\n}\n\nfunction getDefaultValue(description: Joi.Description) {\n  const defaultSpec = get(description, \"flags.default\")\n\n  if (defaultSpec === undefined) {\n    return\n  } else if (defaultSpec && defaultSpec.function) {\n    return defaultSpec.function()\n  } else {\n    return defaultSpec\n  }\n}\n\nfunction indent(lines: string[], level: number) {\n  const prefix = padEnd(\"\", level * 2, \" \")\n  return lines.map(line => prefix + line)\n}\n\nfunction indentFromSecondLine(lines: string[], level: number) {\n  return [...lines.slice(0, 1), ...indent(lines.slice(1), level)]\n}\n\nexport function renderSchemaDescription(description: Joi.Description, opts: RenderOpts) {\n  const { level = 0 } = opts\n  const indentSpaces = level * 2\n  const descriptionWidth = maxWidth - indentSpaces - 2\n\n  const output: string[] = []\n  const defaultValue = getDefaultValue(description)\n\n  switch (description.type) {\n    case \"object\":\n      const children = Object.entries(description.children || {})\n\n      if (!children.length) {\n        if (defaultValue) {\n          output.push(\"\", ...safeDump(defaultValue).trim().split(\"\\n\"))\n        } else {\n          output.push(\"{}\")\n        }\n        break\n      }\n\n      output.push(\"\")\n\n      for (const [key, keyDescription] of children) {\n        if (get(keyDescription, \"meta[0].internal\")) {\n          continue\n        }\n\n        output.push(\n          ...renderCommentDescription(keyDescription, descriptionWidth, opts),\n          `${key}: ${renderSchemaDescription(keyDescription, { ...opts, level: level + 1 })}`,\n          \"\",\n        )\n      }\n\n      output.pop()\n\n      break\n\n    case \"array\":\n      if (!description.items.length) {\n        output.push(\"[]\")\n      }\n\n      const itemDescription = description.items[0]\n\n      output.push(\n        \"\",\n        ...renderCommentDescription(itemDescription, descriptionWidth, opts),\n        \"- \" + renderSchemaDescription(itemDescription, { ...opts, level: level + 1 }).trim(),\n        \"\",\n      )\n\n      break\n\n    default:\n      output.push(defaultValue === undefined ? \"\" : defaultValue + \"\")\n  }\n\n  // we don't indent the first line\n  return indentFromSecondLine(output, level)\n    .map(line => line.trimRight())\n    .join(\"\\n\")\n}\n\nexport function generateConfigReferenceDocs(docsRoot: string) {\n  const referenceDir = resolve(docsRoot, \"reference\")\n  const outputPath = resolve(referenceDir, \"config.md\")\n\n  const yaml = renderSchemaDescription(configSchema.describe(), { required: true })\n  const moduleTypes = builtInModuleTypes.map(({ name, schema }) => {\n    schema = Joi.object().keys({\n      module: baseModuleSpecSchema.concat(schema),\n    })\n    return {\n      name,\n      yaml: renderSchemaDescription(schema.describe(), { required: true }),\n    }\n  })\n\n  const templatePath = resolve(__dirname, \"templates\", \"config.hbs\")\n  const template = handlebars.compile(readFileSync(templatePath).toString())\n  const markdown = template({ yaml, moduleTypes })\n\n  writeFileSync(outputPath, markdown)\n}\n"]} diff --git a/garden-service/build/docs/generate.d.ts b/garden-service/build/docs/generate.d.ts new file mode 100644 index 00000000000..796b31808d4 --- /dev/null +++ b/garden-service/build/docs/generate.d.ts @@ -0,0 +1,2 @@ +export declare function generateDocs(targetDir: string): void; +//# sourceMappingURL=generate.d.ts.map \ No newline at end of file diff --git a/garden-service/build/docs/generate.js b/garden-service/build/docs/generate.js new file mode 100644 index 00000000000..a8dea9dc8e0 --- /dev/null +++ b/garden-service/build/docs/generate.js @@ -0,0 +1,26 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const commands_1 = require("./commands"); +const config_1 = require("./config"); +const process_1 = require("process"); +const template_strings_1 = require("./template-strings"); +function generateDocs(targetDir) { + const docsRoot = path_1.resolve(process.cwd(), targetDir); + commands_1.generateCommandReferenceDocs(docsRoot); + config_1.generateConfigReferenceDocs(docsRoot); + template_strings_1.generateTemplateStringReferenceDocs(docsRoot); +} +exports.generateDocs = generateDocs; +if (require.main === module) { + generateDocs(process_1.argv[2]); +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImRvY3MvZ2VuZXJhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7QUFFSCwrQkFBOEI7QUFDOUIseUNBQXlEO0FBQ3pELHFDQUFzRDtBQUN0RCxxQ0FBOEI7QUFDOUIseURBQXdFO0FBRXhFLFNBQWdCLFlBQVksQ0FBQyxTQUFpQjtJQUM1QyxNQUFNLFFBQVEsR0FBRyxjQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFFLFNBQVMsQ0FBQyxDQUFBO0lBQ2xELHVDQUE0QixDQUFDLFFBQVEsQ0FBQyxDQUFBO0lBQ3RDLG9DQUEyQixDQUFDLFFBQVEsQ0FBQyxDQUFBO0lBQ3JDLHNEQUFtQyxDQUFDLFFBQVEsQ0FBQyxDQUFBO0FBQy9DLENBQUM7QUFMRCxvQ0FLQztBQUVELElBQUksT0FBTyxDQUFDLElBQUksS0FBSyxNQUFNLEVBQUU7SUFDM0IsWUFBWSxDQUFDLGNBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBO0NBQ3RCIiwiZmlsZSI6ImRvY3MvZ2VuZXJhdGUuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChDKSAyMDE4IEdhcmRlbiBUZWNobm9sb2dpZXMsIEluYy4gPGluZm9AZ2FyZGVuLmlvPlxuICpcbiAqIFRoaXMgU291cmNlIENvZGUgRm9ybSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGUgTW96aWxsYSBQdWJsaWNcbiAqIExpY2Vuc2UsIHYuIDIuMC4gSWYgYSBjb3B5IG9mIHRoZSBNUEwgd2FzIG5vdCBkaXN0cmlidXRlZCB3aXRoIHRoaXNcbiAqIGZpbGUsIFlvdSBjYW4gb2J0YWluIG9uZSBhdCBodHRwOi8vbW96aWxsYS5vcmcvTVBMLzIuMC8uXG4gKi9cblxuaW1wb3J0IHsgcmVzb2x2ZSB9IGZyb20gXCJwYXRoXCJcbmltcG9ydCB7IGdlbmVyYXRlQ29tbWFuZFJlZmVyZW5jZURvY3MgfSBmcm9tIFwiLi9jb21tYW5kc1wiXG5pbXBvcnQgeyBnZW5lcmF0ZUNvbmZpZ1JlZmVyZW5jZURvY3MgfSBmcm9tIFwiLi9jb25maWdcIlxuaW1wb3J0IHsgYXJndiB9IGZyb20gXCJwcm9jZXNzXCJcbmltcG9ydCB7IGdlbmVyYXRlVGVtcGxhdGVTdHJpbmdSZWZlcmVuY2VEb2NzIH0gZnJvbSBcIi4vdGVtcGxhdGUtc3RyaW5nc1wiXG5cbmV4cG9ydCBmdW5jdGlvbiBnZW5lcmF0ZURvY3ModGFyZ2V0RGlyOiBzdHJpbmcpIHtcbiAgY29uc3QgZG9jc1Jvb3QgPSByZXNvbHZlKHByb2Nlc3MuY3dkKCksIHRhcmdldERpcilcbiAgZ2VuZXJhdGVDb21tYW5kUmVmZXJlbmNlRG9jcyhkb2NzUm9vdClcbiAgZ2VuZXJhdGVDb25maWdSZWZlcmVuY2VEb2NzKGRvY3NSb290KVxuICBnZW5lcmF0ZVRlbXBsYXRlU3RyaW5nUmVmZXJlbmNlRG9jcyhkb2NzUm9vdClcbn1cblxuaWYgKHJlcXVpcmUubWFpbiA9PT0gbW9kdWxlKSB7XG4gIGdlbmVyYXRlRG9jcyhhcmd2WzJdKVxufVxuIl19 diff --git a/garden-service/build/docs/template-strings.d.ts b/garden-service/build/docs/template-strings.d.ts new file mode 100644 index 00000000000..5d589c54224 --- /dev/null +++ b/garden-service/build/docs/template-strings.d.ts @@ -0,0 +1,2 @@ +export declare function generateTemplateStringReferenceDocs(docsRoot: string): void; +//# sourceMappingURL=template-strings.d.ts.map \ No newline at end of file diff --git a/garden-service/build/docs/template-strings.js b/garden-service/build/docs/template-strings.js new file mode 100644 index 00000000000..26a74f2de28 --- /dev/null +++ b/garden-service/build/docs/template-strings.js @@ -0,0 +1,30 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const config_1 = require("./config"); +const config_context_1 = require("../config/config-context"); +const fs_1 = require("fs"); +const handlebars = require("handlebars"); +function generateTemplateStringReferenceDocs(docsRoot) { + const referenceDir = path_1.resolve(docsRoot, "reference"); + const outputPath = path_1.resolve(referenceDir, "template-strings.md"); + const projectContext = config_1.renderSchemaDescription(config_context_1.ProjectConfigContext.getSchema().describe(), { required: false }); + const moduleContext = config_1.renderSchemaDescription(config_context_1.ModuleConfigContext.getSchema().describe(), { required: false }); + const templatePath = path_1.resolve(__dirname, "templates", "template-strings.hbs"); + const template = handlebars.compile(fs_1.readFileSync(templatePath).toString()); + const markdown = template({ projectContext, moduleContext }); + fs_1.writeFileSync(outputPath, markdown); +} +exports.generateTemplateStringReferenceDocs = generateTemplateStringReferenceDocs; +if (require.main === module) { + generateTemplateStringReferenceDocs(path_1.resolve(__dirname, "..", "..", "..", "docs")); +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/exceptions.d.ts b/garden-service/build/exceptions.d.ts new file mode 100644 index 00000000000..8742be941e6 --- /dev/null +++ b/garden-service/build/exceptions.d.ts @@ -0,0 +1,49 @@ +export interface GardenError { + type: string; + message: string; + detail?: any; + stack?: string; +} +export declare abstract class GardenBaseError extends Error implements GardenError { + abstract type: string; + detail: any; + constructor(message: string, detail: object); +} +export declare function toGardenError(err: Error | GardenError): GardenError; +export declare class AuthenticationError extends GardenBaseError { + type: string; +} +export declare class ConfigurationError extends GardenBaseError { + type: string; +} +export declare class LocalConfigError extends GardenBaseError { + type: string; +} +export declare class ValidationError extends GardenBaseError { + type: string; +} +export declare class PluginError extends GardenBaseError { + type: string; +} +export declare class ParameterError extends GardenBaseError { + type: string; +} +export declare class NotImplementedError extends GardenBaseError { + type: string; +} +export declare class DeploymentError extends GardenBaseError { + type: string; +} +export declare class RuntimeError extends GardenBaseError { + type: string; +} +export declare class InternalError extends GardenBaseError { + type: string; +} +export declare class TimeoutError extends GardenBaseError { + type: string; +} +export declare class NotFoundError extends GardenBaseError { + type: string; +} +//# sourceMappingURL=exceptions.d.ts.map \ No newline at end of file diff --git a/garden-service/build/exceptions.js b/garden-service/build/exceptions.js new file mode 100644 index 00000000000..974a077562e --- /dev/null +++ b/garden-service/build/exceptions.js @@ -0,0 +1,113 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +class GardenBaseError extends Error { + constructor(message, detail) { + super(message); + this.detail = detail; + } +} +exports.GardenBaseError = GardenBaseError; +function toGardenError(err) { + if (err instanceof GardenBaseError) { + return err; + } + else { + const out = new RuntimeError(err.message, {}); + out.stack = err.stack; + return out; + } +} +exports.toGardenError = toGardenError; +class AuthenticationError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "authentication"; + } +} +exports.AuthenticationError = AuthenticationError; +class ConfigurationError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "configuration"; + } +} +exports.ConfigurationError = ConfigurationError; +class LocalConfigError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "local-config"; + } +} +exports.LocalConfigError = LocalConfigError; +class ValidationError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "validation"; + } +} +exports.ValidationError = ValidationError; +class PluginError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "plugin"; + } +} +exports.PluginError = PluginError; +class ParameterError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "parameter"; + } +} +exports.ParameterError = ParameterError; +class NotImplementedError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "not-implemented"; + } +} +exports.NotImplementedError = NotImplementedError; +class DeploymentError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "deployment"; + } +} +exports.DeploymentError = DeploymentError; +class RuntimeError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "runtime"; + } +} +exports.RuntimeError = RuntimeError; +class InternalError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "internal"; + } +} +exports.InternalError = InternalError; +class TimeoutError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "timeout"; + } +} +exports.TimeoutError = TimeoutError; +class NotFoundError extends GardenBaseError { + constructor() { + super(...arguments); + this.type = "not-found"; + } +} +exports.NotFoundError = NotFoundError; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/garden.d.ts b/garden-service/build/garden.d.ts new file mode 100644 index 00000000000..4b3030b39fe --- /dev/null +++ b/garden-service/build/garden.d.ts @@ -0,0 +1,135 @@ +import { TreeCache } from "./cache"; +import { Module } from "./types/module"; +import { Environment, SourceConfig } from "./config/project"; +import { VcsHandler, ModuleVersion } from "./vcs/base"; +import { BuildDir } from "./build-dir"; +import { TaskResults } from "./task-graph"; +import { Logger } from "./logger/logger"; +import { PluginActions } from "./types/plugin/plugin"; +import { Service } from "./types/service"; +import { GardenConfig } from "./config/base"; +import { Task } from "./tasks/base"; +import { LocalConfigStore } from "./config-store"; +import { ExternalSourceType } from "./util/ext-source-util"; +import { BuildDependencyConfig, ModuleConfig } from "./config/module"; +import { ActionHelper } from "./actions"; +import { ModuleAndServiceActions, Plugins } from "./types/plugin/plugin"; +export interface ActionHandlerMap { + [actionName: string]: PluginActions[T]; +} +export interface ModuleActionHandlerMap { + [actionName: string]: ModuleAndServiceActions[T]; +} +export declare type PluginActionMap = { + [A in keyof PluginActions]: { + [pluginName: string]: PluginActions[A]; + }; +}; +export declare type ModuleActionMap = { + [A in keyof ModuleAndServiceActions]: { + [moduleType: string]: { + [pluginName: string]: ModuleAndServiceActions[A]; + }; + }; +}; +export interface ContextOpts { + config?: GardenConfig; + env?: string; + logger?: Logger; + plugins?: Plugins; +} +export declare class Garden { + readonly projectRoot: string; + readonly projectName: string; + readonly environment: Environment; + readonly projectSources: SourceConfig[]; + readonly buildDir: BuildDir; + readonly log: Logger; + readonly actionHandlers: PluginActionMap; + readonly moduleActionHandlers: ModuleActionMap; + private readonly loadedPlugins; + private moduleConfigs; + private modulesScanned; + private readonly registeredPlugins; + private readonly serviceNameIndex; + private readonly taskGraph; + readonly localConfigStore: LocalConfigStore; + readonly vcs: VcsHandler; + readonly cache: TreeCache; + readonly actions: ActionHelper; + constructor(projectRoot: string, projectName: string, environment: Environment, projectSources: SourceConfig[], buildDir: BuildDir, logger?: Logger); + static factory(currentDirectory: string, { env, config, logger, plugins }?: ContextOpts): Promise; + getPluginContext(providerName: string): import("./plugin-context").PluginContext; + clearBuilds(): Promise; + addTask(task: Task): Promise; + processTasks(): Promise; + private registerPlugin; + private loadPlugin; + private getPlugin; + private addActionHandler; + private addModuleActionHandler; + getModules(names?: string[], noScan?: boolean): Promise; + /** + * Returns the module with the specified name. Throws error if it doesn't exist. + */ + getModule(name: string, noScan?: boolean): Promise; + /** + * Given the provided lists of build and service dependencies, return a list of all modules + * required to satisfy those dependencies. + */ + resolveModuleDependencies(buildDependencies: BuildDependencyConfig[], serviceDependencies: string[]): any; + /** + * Given a module, and a list of dependencies, resolve the version for that combination of modules. + * The combined version is a either the latest dirty module version (if any), or the hash of the module version + * and the versions of its dependencies (in sorted order). + */ + resolveVersion(moduleName: string, moduleDependencies: BuildDependencyConfig[], force?: boolean): Promise; + getServices(names?: string[], noScan?: boolean): Promise; + /** + * Returns the service with the specified name. Throws error if it doesn't exist. + */ + getService(name: string, noScan?: boolean): Promise>; + scanModules(force?: boolean): Promise; + private detectCircularDependencies; + addModule(config: ModuleConfig, force?: boolean): Promise; + resolveModule(nameOrLocation: string): Promise; + /** + * Clones the project/module source if needed and returns the path (either from .garden/sources or from a local path) + */ + loadExtSourcePath({ name, repositoryUrl, sourceType }: { + name: string; + repositoryUrl: string; + sourceType: ExternalSourceType; + }): Promise; + /** + * Get a handler for the specified action. + */ + getActionHandlers(actionType: T, pluginName?: string): ActionHandlerMap; + /** + * Get a handler for the specified module action. + */ + getModuleActionHandlers({ actionType, moduleType, pluginName }: { + actionType: T; + moduleType: string; + pluginName?: string; + }): ModuleActionHandlerMap; + private filterActionHandlers; + /** + * Get the last configured handler for the specified action (and optionally module type). + */ + getActionHandler({ actionType, pluginName, defaultHandler }: { + actionType: T; + pluginName?: string; + defaultHandler?: PluginActions[T]; + }): PluginActions[T]; + /** + * Get the last configured handler for the specified action. + */ + getModuleActionHandler({ actionType, moduleType, pluginName, defaultHandler }: { + actionType: T; + moduleType: string; + pluginName?: string; + defaultHandler?: ModuleAndServiceActions[T]; + }): ModuleAndServiceActions[T]; +} +//# sourceMappingURL=garden.d.ts.map \ No newline at end of file diff --git a/garden-service/build/garden.js b/garden-service/build/garden.js new file mode 100644 index 00000000000..de46e159d77 --- /dev/null +++ b/garden-service/build/garden.js @@ -0,0 +1,673 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const path_1 = require("path"); +const lodash_1 = require("lodash"); +const AsyncLock = require("async-lock"); +const cache_1 = require("./cache"); +const plugins_1 = require("./plugins/plugins"); +const module_1 = require("./types/module"); +const plugin_1 = require("./types/plugin/plugin"); +const project_1 = require("./config/project"); +const util_1 = require("./util/util"); +const constants_1 = require("./constants"); +const exceptions_1 = require("./exceptions"); +const git_1 = require("./vcs/git"); +const build_dir_1 = require("./build-dir"); +const task_graph_1 = require("./task-graph"); +const logger_1 = require("./logger/logger"); +const plugin_2 = require("./types/plugin/plugin"); +const common_1 = require("./config/common"); +const template_string_1 = require("./template-string"); +const base_1 = require("./config/base"); +const config_store_1 = require("./config-store"); +const detectCycles_1 = require("./util/detectCycles"); +const ext_source_util_1 = require("./util/ext-source-util"); +const config_context_1 = require("./config/config-context"); +const file_writer_1 = require("./logger/writers/file-writer"); +const log_node_1 = require("./logger/log-node"); +const actions_1 = require("./actions"); +const plugin_context_1 = require("./plugin-context"); +const scanLock = new AsyncLock(); +const fileWriterConfigs = [ + { filename: "development.log" }, + { filename: constants_1.ERROR_LOG_FILENAME, level: log_node_1.LogLevel.error }, + { filename: constants_1.ERROR_LOG_FILENAME, level: log_node_1.LogLevel.error, path: ".", truncatePrevious: true }, +]; +class Garden { + constructor(projectRoot, projectName, environment, projectSources = [], buildDir, logger) { + this.projectRoot = projectRoot; + this.projectName = projectName; + this.environment = environment; + this.projectSources = projectSources; + this.buildDir = buildDir; + this.modulesScanned = false; + this.log = logger || logger_1.getLogger(); + // TODO: Support other VCS options. + this.vcs = new git_1.GitHandler(this.projectRoot); + this.localConfigStore = new config_store_1.LocalConfigStore(this.projectRoot); + this.cache = new cache_1.TreeCache(); + this.moduleConfigs = {}; + this.serviceNameIndex = {}; + this.loadedPlugins = {}; + this.registeredPlugins = {}; + this.actionHandlers = lodash_1.fromPairs(plugin_2.pluginActionNames.map(n => [n, {}])); + this.moduleActionHandlers = lodash_1.fromPairs(plugin_1.moduleActionNames.map(n => [n, {}])); + this.taskGraph = new task_graph_1.TaskGraph(this); + this.actions = new actions_1.ActionHelper(this); + } + static factory(currentDirectory, { env, config, logger, plugins = {} } = {}) { + return __awaiter(this, void 0, void 0, function* () { + let parsedConfig; + if (config) { + parsedConfig = common_1.validate(config, base_1.configSchema, { context: "root configuration" }); + if (!parsedConfig.project) { + throw new exceptions_1.ConfigurationError(`Supplied config does not contain a project configuration`, { + currentDirectory, + config, + }); + } + } + else { + config = yield base_1.findProjectConfig(currentDirectory); + if (!config || !config.project) { + throw new exceptions_1.ConfigurationError(`Not a project directory (or any of the parent directories): ${currentDirectory}`, { currentDirectory }); + } + parsedConfig = yield template_string_1.resolveTemplateStrings(config, new config_context_1.ProjectConfigContext()); + } + const projectRoot = parsedConfig.path; + const { defaultEnvironment, environments, name: projectName, environmentDefaults, sources: projectSources, } = parsedConfig.project; + if (!env) { + env = defaultEnvironment; + } + const parts = env.split("."); + const environmentName = parts[0]; + const namespace = parts.slice(1).join(".") || constants_1.DEFAULT_NAMESPACE; + const environmentConfig = util_1.findByName(environments, environmentName); + if (!environmentConfig) { + throw new exceptions_1.ParameterError(`Project ${projectName} does not specify environment ${environmentName}`, { + projectName, + env, + definedEnvironments: util_1.getNames(environments), + }); + } + if (!environmentConfig.providers || environmentConfig.providers.length === 0) { + throw new exceptions_1.ConfigurationError(`Environment '${environmentName}' does not specify any providers`, { + projectName, + env, + environmentConfig, + }); + } + if (namespace.startsWith("garden-")) { + throw new exceptions_1.ParameterError(`Namespace cannot start with "garden-"`, { + environmentConfig, + namespace, + }); + } + const fixedProviders = plugins_1.fixedPlugins.map(name => ({ name })); + const mergedProviders = lodash_1.merge(fixedProviders, lodash_1.keyBy(environmentDefaults.providers, "name"), lodash_1.keyBy(environmentConfig.providers, "name")); + // Resolve the project configuration based on selected environment + const environment = { + name: environmentConfig.name, + providers: Object.values(mergedProviders), + variables: lodash_1.merge({}, environmentDefaults.variables, environmentConfig.variables), + }; + const buildDir = yield build_dir_1.BuildDir.factory(projectRoot); + // Register log writers + if (logger) { + for (const writerConfig of fileWriterConfigs) { + logger.writers.push(yield file_writer_1.FileWriter.factory(Object.assign({ level: logger.level, root: projectRoot }, writerConfig))); + } + } + const garden = new Garden(projectRoot, projectName, environment, projectSources, buildDir, logger); + // Register plugins + for (const [name, pluginFactory] of Object.entries(Object.assign({}, plugins_1.builtinPlugins, plugins))) { + garden.registerPlugin(name, pluginFactory); + } + // Load configured plugins + // Validate configuration + for (const provider of environment.providers) { + yield garden.loadPlugin(provider.name, provider); + } + return garden; + }); + } + getPluginContext(providerName) { + return plugin_context_1.createPluginContext(this, providerName); + } + clearBuilds() { + return __awaiter(this, void 0, void 0, function* () { + return this.buildDir.clear(); + }); + } + addTask(task) { + return __awaiter(this, void 0, void 0, function* () { + yield this.taskGraph.addTask(task); + }); + } + processTasks() { + return __awaiter(this, void 0, void 0, function* () { + return this.taskGraph.processTasks(); + }); + } + registerPlugin(name, moduleOrFactory) { + let factory; + if (typeof moduleOrFactory === "function") { + factory = moduleOrFactory; + } + else if (lodash_1.isString(moduleOrFactory)) { + let moduleNameOrLocation = moduleOrFactory; + const parsedLocation = path_1.parse(moduleNameOrLocation); + // allow relative references to project root + if (path_1.parse(moduleNameOrLocation).dir !== "") { + console.log(this.projectRoot); + console.log(moduleNameOrLocation); + moduleNameOrLocation = path_1.resolve(this.projectRoot, moduleNameOrLocation); + } + let pluginModule; + try { + pluginModule = require(moduleNameOrLocation); + } + catch (error) { + throw new exceptions_1.ConfigurationError(`Unable to load plugin "${moduleNameOrLocation}" (could not load module: ${error.message})`, { + message: error.message, + moduleNameOrLocation, + }); + } + try { + pluginModule = common_1.validate(pluginModule, plugin_1.pluginModuleSchema, { context: `plugin module "${moduleNameOrLocation}"` }); + if (pluginModule.name) { + name = pluginModule.name; + } + else { + if (parsedLocation.name === "index") { + // use parent directory name + name = parsedLocation.dir.split(path_1.sep).slice(-1)[0]; + } + else { + name = parsedLocation.name; + } + } + common_1.validate(name, common_1.joiIdentifier(), { context: `name of plugin "${moduleNameOrLocation}"` }); + } + catch (err) { + throw new exceptions_1.PluginError(`Unable to load plugin: ${err}`, { + moduleNameOrLocation, + err, + }); + } + factory = pluginModule.gardenPlugin; + } + else { + throw new TypeError(`Expected plugin factory function, module name or module path`); + } + this.registeredPlugins[name] = factory; + } + loadPlugin(pluginName, config) { + return __awaiter(this, void 0, void 0, function* () { + const factory = this.registeredPlugins[pluginName]; + if (!factory) { + throw new exceptions_1.ConfigurationError(`Configured plugin '${pluginName}' has not been registered`, { + name: pluginName, + availablePlugins: Object.keys(this.registeredPlugins), + }); + } + let plugin; + try { + plugin = yield factory({ + projectName: this.projectName, + config, + logEntry: this.log, + }); + } + catch (error) { + throw new exceptions_1.PluginError(`Unexpected error when loading plugin "${pluginName}": ${error}`, { + pluginName, + error, + }); + } + plugin = common_1.validate(plugin, plugin_1.pluginSchema, { context: `plugin "${pluginName}"` }); + this.loadedPlugins[pluginName] = plugin; + // allow plugins to extend their own config (that gets passed to action handlers) + const providerConfig = util_1.findByName(this.environment.providers, pluginName); + if (providerConfig) { + lodash_1.extend(providerConfig, plugin.config, config); + } + else { + this.environment.providers.push(lodash_1.extend({ name: pluginName }, plugin.config, config)); + } + for (const modulePath of plugin.modules || []) { + let moduleConfig = yield this.resolveModule(modulePath); + if (!moduleConfig) { + throw new exceptions_1.PluginError(`Could not load module "${modulePath}" specified in plugin "${pluginName}"`, { + pluginName, + modulePath, + }); + } + moduleConfig.plugin = pluginName; + yield this.addModule(moduleConfig); + } + const actions = plugin.actions || {}; + for (const actionType of plugin_2.pluginActionNames) { + const handler = actions[actionType]; + handler && this.addActionHandler(pluginName, actionType, handler); + } + const moduleActions = plugin.moduleActions || {}; + for (const moduleType of Object.keys(moduleActions)) { + for (const actionType of plugin_1.moduleActionNames) { + const handler = moduleActions[moduleType][actionType]; + handler && this.addModuleActionHandler(pluginName, actionType, moduleType, handler); + } + } + }); + } + getPlugin(pluginName) { + const plugin = this.loadedPlugins[pluginName]; + if (!plugin) { + throw new exceptions_1.PluginError(`Could not find plugin ${pluginName}. Are you missing a provider configuration?`, { + pluginName, + availablePlugins: Object.keys(this.loadedPlugins), + }); + } + return plugin; + } + addActionHandler(pluginName, actionType, handler) { + const plugin = this.getPlugin(pluginName); + const schema = plugin_1.pluginActionDescriptions[actionType].resultSchema; + const wrapped = (...args) => __awaiter(this, void 0, void 0, function* () { + const result = yield handler.apply(plugin, args); + return common_1.validate(result, schema, { context: `${actionType} output from plugin ${pluginName}` }); + }); + wrapped["actionType"] = actionType; + wrapped["pluginName"] = pluginName; + this.actionHandlers[actionType][pluginName] = wrapped; + } + addModuleActionHandler(pluginName, actionType, moduleType, handler) { + const plugin = this.getPlugin(pluginName); + const schema = plugin_1.moduleActionDescriptions[actionType].resultSchema; + const wrapped = (...args) => __awaiter(this, void 0, void 0, function* () { + const result = yield handler.apply(plugin, args); + return common_1.validate(result, schema, { context: `${actionType} output from plugin ${pluginName}` }); + }); + wrapped["actionType"] = actionType; + wrapped["pluginName"] = pluginName; + wrapped["moduleType"] = moduleType; + if (!this.moduleActionHandlers[actionType]) { + this.moduleActionHandlers[actionType] = {}; + } + if (!this.moduleActionHandlers[actionType][moduleType]) { + this.moduleActionHandlers[actionType][moduleType] = {}; + } + this.moduleActionHandlers[actionType][moduleType][pluginName] = wrapped; + } + /* + Returns all modules that are registered in this context. + Scans for modules in the project root if it hasn't already been done. + */ + getModules(names, noScan) { + return __awaiter(this, void 0, void 0, function* () { + if (!this.modulesScanned && !noScan) { + yield this.scanModules(); + } + let configs; + if (!!names) { + configs = []; + const missing = []; + for (const name of names) { + const module = this.moduleConfigs[name]; + if (!module) { + missing.push(name); + } + else { + configs.push(module); + } + } + if (missing.length) { + throw new exceptions_1.ParameterError(`Could not find module(s): ${missing.join(", ")}`, { + missing, + available: Object.keys(this.moduleConfigs), + }); + } + } + else { + configs = Object.values(this.moduleConfigs); + } + return Bluebird.map(configs, config => module_1.moduleFromConfig(this, config)); + }); + } + /** + * Returns the module with the specified name. Throws error if it doesn't exist. + */ + getModule(name, noScan) { + return __awaiter(this, void 0, void 0, function* () { + return (yield this.getModules([name], noScan))[0]; + }); + } + /** + * Given the provided lists of build and service dependencies, return a list of all modules + * required to satisfy those dependencies. + */ + resolveModuleDependencies(buildDependencies, serviceDependencies) { + return __awaiter(this, void 0, void 0, function* () { + const buildDeps = yield Bluebird.map(buildDependencies, (dep) => __awaiter(this, void 0, void 0, function* () { + const moduleKey = module_1.getModuleKey(dep.name, dep.plugin); + const module = yield this.getModule(moduleKey); + return [module].concat(yield this.resolveModuleDependencies(module.build.dependencies, [])); + })); + const runtimeDeps = yield Bluebird.map(serviceDependencies, (serviceName) => __awaiter(this, void 0, void 0, function* () { + const service = yield this.getService(serviceName); + return this.resolveModuleDependencies([{ name: service.module.name, copy: [] }], service.config.dependencies || []); + })); + const deps = lodash_1.flatten(buildDeps).concat(lodash_1.flatten(runtimeDeps)); + return lodash_1.sortBy(lodash_1.uniqBy(deps, "name"), "name"); + }); + } + /** + * Given a module, and a list of dependencies, resolve the version for that combination of modules. + * The combined version is a either the latest dirty module version (if any), or the hash of the module version + * and the versions of its dependencies (in sorted order). + */ + resolveVersion(moduleName, moduleDependencies, force = false) { + return __awaiter(this, void 0, void 0, function* () { + const config = this.moduleConfigs[moduleName]; + const cacheKey = ["moduleVersions", moduleName]; + if (!force) { + const cached = this.cache.get(cacheKey); + if (cached) { + return cached; + } + } + const dependencyKeys = moduleDependencies.map(dep => module_1.getModuleKey(dep.name, dep.plugin)); + const dependencies = Object.values(util_1.pickKeys(this.moduleConfigs, dependencyKeys, "module config")); + const cacheContexts = dependencies.concat([config]).map(c => module_1.getModuleCacheContext(c)); + const version = yield this.vcs.resolveVersion(config, dependencies); + this.cache.set(cacheKey, version, ...cacheContexts); + return version; + }); + } + /* + Returns all services that are registered in this context, or the ones specified. + Scans for modules and services in the project root if it hasn't already been done. + */ + getServices(names, noScan) { + return __awaiter(this, void 0, void 0, function* () { + if (!this.modulesScanned && !noScan) { + yield this.scanModules(); + } + const picked = names ? util_1.pickKeys(this.serviceNameIndex, names, "service") : this.serviceNameIndex; + return Bluebird.map(Object.entries(picked), ([serviceName, moduleName]) => __awaiter(this, void 0, void 0, function* () { + const module = yield this.getModule(moduleName); + const config = util_1.findByName(module.serviceConfigs, serviceName); + return { + name: serviceName, + config, + module, + spec: config.spec, + }; + })); + }); + } + /** + * Returns the service with the specified name. Throws error if it doesn't exist. + */ + getService(name, noScan) { + return __awaiter(this, void 0, void 0, function* () { + return (yield this.getServices([name], noScan))[0]; + }); + } + /* + Scans the project root for modules and adds them to the context. + */ + scanModules(force = false) { + return __awaiter(this, void 0, void 0, function* () { + return scanLock.acquire("scan-modules", () => __awaiter(this, void 0, void 0, function* () { + if (this.modulesScanned && !force) { + return; + } + let extSourcePaths = []; + // Add external sources that are defined at the project level. External sources are either kept in + // the .garden/sources dir (and cloned there if needed), or they're linked to a local path via the link command. + for (const { name, repositoryUrl } of this.projectSources) { + const path = yield this.loadExtSourcePath({ name, repositoryUrl, sourceType: "project" }); + extSourcePaths.push(path); + } + const dirsToScan = [this.projectRoot, ...extSourcePaths]; + const modulePaths = lodash_1.flatten(yield Bluebird.map(dirsToScan, (dir) => __awaiter(this, void 0, void 0, function* () { + var e_1, _a; + const ignorer = yield util_1.getIgnorer(dir); + const scanOpts = { + filter: (path) => { + const relPath = path_1.relative(this.projectRoot, path); + return !ignorer.ignores(relPath); + }, + }; + const paths = []; + try { + for (var _b = __asyncValues(util_1.scanDirectory(dir, scanOpts)), _c; _c = yield _b.next(), !_c.done;) { + const item = _c.value; + if (!item) { + continue; + } + const parsedPath = path_1.parse(item.path); + if (parsedPath.base !== constants_1.MODULE_CONFIG_FILENAME) { + continue; + } + paths.push(parsedPath.dir); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + return paths; + }))).filter(Boolean); + yield Bluebird.map(modulePaths, (path) => __awaiter(this, void 0, void 0, function* () { + const config = yield this.resolveModule(path); + config && (yield this.addModule(config)); + })); + this.modulesScanned = true; + yield this.detectCircularDependencies(); + const moduleConfigContext = new config_context_1.ModuleConfigContext(this, this.environment, Object.values(this.moduleConfigs)); + this.moduleConfigs = yield template_string_1.resolveTemplateStrings(this.moduleConfigs, moduleConfigContext); + })); + }); + } + detectCircularDependencies() { + return __awaiter(this, void 0, void 0, function* () { + const modules = yield this.getModules(); + const services = yield this.getServices(); + return detectCycles_1.detectCircularDependencies(modules, services); + }); + } + /* + Adds the specified module to the context + + @param force - add the module again, even if it's already registered + */ + addModule(config, force = false) { + return __awaiter(this, void 0, void 0, function* () { + const validateHandler = yield this.getModuleActionHandler({ actionType: "validate", moduleType: config.type }); + const ctx = this.getPluginContext(validateHandler["pluginName"]); + config = yield validateHandler({ ctx, moduleConfig: config }); + // FIXME: this is rather clumsy + config.name = module_1.getModuleKey(config.name, config.plugin); + if (!force && this.moduleConfigs[config.name]) { + const pathA = path_1.relative(this.projectRoot, this.moduleConfigs[config.name].path); + const pathB = path_1.relative(this.projectRoot, config.path); + throw new exceptions_1.ConfigurationError(`Module ${config.name} is declared multiple times ('${pathA}' and '${pathB}')`, { pathA, pathB }); + } + this.moduleConfigs[config.name] = config; + // Add to service-module map + for (const serviceConfig of config.serviceConfigs) { + const serviceName = serviceConfig.name; + if (!force && this.serviceNameIndex[serviceName]) { + throw new exceptions_1.ConfigurationError(`Service names must be unique - ${serviceName} is declared multiple times ` + + `(in '${this.serviceNameIndex[serviceName]}' and '${config.name}')`, { + serviceName, + moduleA: this.serviceNameIndex[serviceName], + moduleB: config.name, + }); + } + this.serviceNameIndex[serviceName] = config.name; + } + if (this.modulesScanned) { + // need to re-run this if adding modules after initial scan + yield this.detectCircularDependencies(); + } + }); + } + /* + Maps the provided name or locator to a Module. We first look for a module in the + project with the provided name. If it does not exist, we treat it as a path + (resolved with the project path as a base path) and attempt to load the module + from there. + */ + resolveModule(nameOrLocation) { + return __awaiter(this, void 0, void 0, function* () { + const parsedPath = path_1.parse(nameOrLocation); + if (parsedPath.dir === "") { + // Looks like a name + const existingModule = this.moduleConfigs[nameOrLocation]; + if (!existingModule) { + throw new exceptions_1.ConfigurationError(`Module ${nameOrLocation} could not be found`, { + name: nameOrLocation, + }); + } + return existingModule; + } + // Looks like a path + const path = path_1.resolve(this.projectRoot, nameOrLocation); + const config = yield base_1.loadConfig(this.projectRoot, path); + if (!config || !config.module) { + return null; + } + const moduleConfig = lodash_1.cloneDeep(config.module); + if (moduleConfig.repositoryUrl) { + moduleConfig.path = yield this.loadExtSourcePath({ + name: moduleConfig.name, + repositoryUrl: moduleConfig.repositoryUrl, + sourceType: "module", + }); + } + return moduleConfig; + }); + } + //=========================================================================== + //region Internal helpers + //=========================================================================== + /** + * Clones the project/module source if needed and returns the path (either from .garden/sources or from a local path) + */ + loadExtSourcePath({ name, repositoryUrl, sourceType }) { + return __awaiter(this, void 0, void 0, function* () { + const linkedSources = yield ext_source_util_1.getLinkedSources(this, sourceType); + const linked = util_1.findByName(linkedSources, name); + if (linked) { + return linked.path; + } + const path = yield this.vcs.ensureRemoteSource({ name, sourceType, url: repositoryUrl, logEntry: this.log }); + return path; + }); + } + /** + * Get a handler for the specified action. + */ + getActionHandlers(actionType, pluginName) { + return this.filterActionHandlers(this.actionHandlers[actionType], pluginName); + } + /** + * Get a handler for the specified module action. + */ + getModuleActionHandlers({ actionType, moduleType, pluginName }) { + return this.filterActionHandlers((this.moduleActionHandlers[actionType] || {})[moduleType], pluginName); + } + filterActionHandlers(handlers, pluginName) { + // make sure plugin is loaded + if (!!pluginName) { + this.getPlugin(pluginName); + } + if (handlers === undefined) { + handlers = {}; + } + return !pluginName ? handlers : lodash_1.pickBy(handlers, (handler) => handler["pluginName"] === pluginName); + } + /** + * Get the last configured handler for the specified action (and optionally module type). + */ + getActionHandler({ actionType, pluginName, defaultHandler }) { + const handlers = Object.values(this.getActionHandlers(actionType, pluginName)); + if (handlers.length) { + return handlers[handlers.length - 1]; + } + else if (defaultHandler) { + defaultHandler["pluginName"] = project_1.defaultProvider.name; + return defaultHandler; + } + const errorDetails = { + requestedHandlerType: actionType, + environment: this.environment.name, + pluginName, + }; + if (pluginName) { + throw new exceptions_1.PluginError(`Plugin '${pluginName}' does not have a '${actionType}' handler.`, errorDetails); + } + else { + throw new exceptions_1.ParameterError(`No '${actionType}' handler configured in environment '${this.environment.name}'. ` + + `Are you missing a provider configuration?`, errorDetails); + } + } + /** + * Get the last configured handler for the specified action. + */ + getModuleActionHandler({ actionType, moduleType, pluginName, defaultHandler }) { + const handlers = Object.values(this.getModuleActionHandlers({ actionType, moduleType, pluginName })); + if (handlers.length) { + return handlers[handlers.length - 1]; + } + else if (defaultHandler) { + defaultHandler["pluginName"] = project_1.defaultProvider.name; + return defaultHandler; + } + const errorDetails = { + requestedHandlerType: actionType, + requestedModuleType: moduleType, + environment: this.environment.name, + pluginName, + }; + if (pluginName) { + throw new exceptions_1.PluginError(`Plugin '${pluginName}' does not have a '${actionType}' handler for module type '${moduleType}'.`, errorDetails); + } + else { + throw new exceptions_1.ParameterError(`No '${actionType}' handler configured for module type '${moduleType}' in environment ` + + `'${this.environment.name}'. Are you missing a provider configuration?`, errorDetails); + } + } +} +exports.Garden = Garden; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["garden.ts"],"names":[],"mappings":"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","file":"garden.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport Bluebird = require(\"bluebird\")\nimport {\n  parse,\n  relative,\n  resolve,\n  sep,\n} from \"path\"\nimport {\n  extend,\n  flatten,\n  isString,\n  fromPairs,\n  merge,\n  keyBy,\n  cloneDeep,\n  pickBy,\n  sortBy,\n  uniqBy,\n} from \"lodash\"\nconst AsyncLock = require(\"async-lock\")\n\nimport { TreeCache } from \"./cache\"\nimport {\n  builtinPlugins,\n  fixedPlugins,\n} from \"./plugins/plugins\"\nimport { Module, moduleFromConfig, getModuleCacheContext, getModuleKey, ModuleConfigMap } from \"./types/module\"\nimport {\n  moduleActionDescriptions,\n  moduleActionNames,\n  pluginActionDescriptions,\n  pluginModuleSchema,\n  pluginSchema,\n} from \"./types/plugin/plugin\"\nimport { Environment, SourceConfig, defaultProvider } from \"./config/project\"\nimport {\n  findByName,\n  getIgnorer,\n  getNames,\n  scanDirectory,\n  pickKeys,\n} from \"./util/util\"\nimport {\n  DEFAULT_NAMESPACE,\n  MODULE_CONFIG_FILENAME,\n  ERROR_LOG_FILENAME,\n} from \"./constants\"\nimport {\n  ConfigurationError,\n  ParameterError,\n  PluginError,\n} from \"./exceptions\"\nimport { VcsHandler, ModuleVersion } from \"./vcs/base\"\nimport { GitHandler } from \"./vcs/git\"\nimport { BuildDir } from \"./build-dir\"\nimport {\n  TaskGraph,\n  TaskResults,\n} from \"./task-graph\"\nimport {\n  getLogger,\n  Logger,\n} from \"./logger/logger\"\nimport {\n  pluginActionNames,\n  PluginActions,\n  PluginFactory,\n  GardenPlugin,\n  ModuleActions,\n} from \"./types/plugin/plugin\"\nimport { joiIdentifier, validate } from \"./config/common\"\nimport { Service } from \"./types/service\"\nimport { resolveTemplateStrings } from \"./template-string\"\nimport {\n  configSchema,\n  GardenConfig,\n  loadConfig,\n  findProjectConfig,\n} from \"./config/base\"\nimport { Task } from \"./tasks/base\"\nimport { LocalConfigStore } from \"./config-store\"\nimport { detectCircularDependencies } from \"./util/detectCycles\"\nimport {\n  getLinkedSources,\n  ExternalSourceType,\n} from \"./util/ext-source-util\"\nimport { BuildDependencyConfig, ModuleConfig } from \"./config/module\"\nimport { ProjectConfigContext, ModuleConfigContext } from \"./config/config-context\"\nimport { FileWriter } from \"./logger/writers/file-writer\"\nimport { LogLevel } from \"./logger/log-node\"\nimport { ActionHelper } from \"./actions\"\nimport { createPluginContext } from \"./plugin-context\"\nimport { ModuleAndServiceActions, Plugins, RegisterPluginParam } from \"./types/plugin/plugin\"\n\nexport interface ActionHandlerMap<T extends keyof PluginActions> {\n  [actionName: string]: PluginActions[T]\n}\n\nexport interface ModuleActionHandlerMap<T extends keyof ModuleAndServiceActions> {\n  [actionName: string]: ModuleAndServiceActions[T]\n}\n\nexport type PluginActionMap = {\n  [A in keyof PluginActions]: {\n    [pluginName: string]: PluginActions[A],\n  }\n}\n\nexport type ModuleActionMap = {\n  [A in keyof ModuleAndServiceActions]: {\n    [moduleType: string]: {\n      [pluginName: string]: ModuleAndServiceActions[A],\n    },\n  }\n}\n\nexport interface ContextOpts {\n  config?: GardenConfig,\n  env?: string,\n  logger?: Logger,\n  plugins?: Plugins,\n}\n\nconst scanLock = new AsyncLock()\n\nconst fileWriterConfigs = [\n  { filename: \"development.log\" },\n  { filename: ERROR_LOG_FILENAME, level: LogLevel.error },\n  { filename: ERROR_LOG_FILENAME, level: LogLevel.error, path: \".\", truncatePrevious: true },\n]\n\nexport class Garden {\n  public readonly log: Logger\n  public readonly actionHandlers: PluginActionMap\n  public readonly moduleActionHandlers: ModuleActionMap\n\n  private readonly loadedPlugins: { [key: string]: GardenPlugin }\n  private moduleConfigs: ModuleConfigMap\n  private modulesScanned: boolean\n  private readonly registeredPlugins: { [key: string]: PluginFactory }\n  private readonly serviceNameIndex: { [key: string]: string }\n  private readonly taskGraph: TaskGraph\n\n  public readonly localConfigStore: LocalConfigStore\n  public readonly vcs: VcsHandler\n  public readonly cache: TreeCache\n  public readonly actions: ActionHelper\n\n  constructor(\n    public readonly projectRoot: string,\n    public readonly projectName: string,\n    public readonly environment: Environment,\n    public readonly projectSources: SourceConfig[] = [],\n    public readonly buildDir: BuildDir,\n    logger?: Logger,\n  ) {\n    this.modulesScanned = false\n    this.log = logger || getLogger()\n    // TODO: Support other VCS options.\n    this.vcs = new GitHandler(this.projectRoot)\n    this.localConfigStore = new LocalConfigStore(this.projectRoot)\n    this.cache = new TreeCache()\n\n    this.moduleConfigs = {}\n    this.serviceNameIndex = {}\n    this.loadedPlugins = {}\n    this.registeredPlugins = {}\n    this.actionHandlers = <PluginActionMap>fromPairs(pluginActionNames.map(n => [n, {}]))\n    this.moduleActionHandlers = <ModuleActionMap>fromPairs(moduleActionNames.map(n => [n, {}]))\n\n    this.taskGraph = new TaskGraph(this)\n    this.actions = new ActionHelper(this)\n  }\n\n  static async factory(currentDirectory: string, { env, config, logger, plugins = {} }: ContextOpts = {}) {\n    let parsedConfig: GardenConfig\n\n    if (config) {\n      parsedConfig = <GardenConfig>validate(config, configSchema, { context: \"root configuration\" })\n\n      if (!parsedConfig.project) {\n        throw new ConfigurationError(`Supplied config does not contain a project configuration`, {\n          currentDirectory,\n          config,\n        })\n      }\n    } else {\n      config = await findProjectConfig(currentDirectory)\n\n      if (!config || !config.project) {\n        throw new ConfigurationError(\n          `Not a project directory (or any of the parent directories): ${currentDirectory}`,\n          { currentDirectory },\n        )\n      }\n\n      parsedConfig = await resolveTemplateStrings(config!, new ProjectConfigContext())\n    }\n\n    const projectRoot = parsedConfig.path\n\n    const {\n      defaultEnvironment,\n      environments,\n      name: projectName,\n      environmentDefaults,\n      sources: projectSources,\n    } = parsedConfig.project!\n\n    if (!env) {\n      env = defaultEnvironment\n    }\n\n    const parts = env.split(\".\")\n    const environmentName = parts[0]\n    const namespace = parts.slice(1).join(\".\") || DEFAULT_NAMESPACE\n\n    const environmentConfig = findByName(environments, environmentName)\n\n    if (!environmentConfig) {\n      throw new ParameterError(`Project ${projectName} does not specify environment ${environmentName}`, {\n        projectName,\n        env,\n        definedEnvironments: getNames(environments),\n      })\n    }\n\n    if (!environmentConfig.providers || environmentConfig.providers.length === 0) {\n      throw new ConfigurationError(`Environment '${environmentName}' does not specify any providers`, {\n        projectName,\n        env,\n        environmentConfig,\n      })\n    }\n\n    if (namespace.startsWith(\"garden-\")) {\n      throw new ParameterError(`Namespace cannot start with \"garden-\"`, {\n        environmentConfig,\n        namespace,\n      })\n    }\n\n    const fixedProviders = fixedPlugins.map(name => ({ name }))\n\n    const mergedProviders = merge(\n      fixedProviders,\n      keyBy(environmentDefaults.providers, \"name\"),\n      keyBy(environmentConfig.providers, \"name\"),\n    )\n\n    // Resolve the project configuration based on selected environment\n    const environment: Environment = {\n      name: environmentConfig.name,\n      providers: Object.values(mergedProviders),\n      variables: merge({}, environmentDefaults.variables, environmentConfig.variables),\n    }\n\n    const buildDir = await BuildDir.factory(projectRoot)\n\n    // Register log writers\n    if (logger) {\n      for (const writerConfig of fileWriterConfigs) {\n        logger.writers.push(\n          await FileWriter.factory({\n            level: logger.level,\n            root: projectRoot,\n            ...writerConfig,\n          }),\n        )\n      }\n    }\n\n    const garden = new Garden(\n      projectRoot,\n      projectName,\n      environment,\n      projectSources,\n      buildDir,\n      logger,\n    )\n\n    // Register plugins\n    for (const [name, pluginFactory] of Object.entries({ ...builtinPlugins, ...plugins })) {\n      garden.registerPlugin(name, pluginFactory)\n    }\n\n    // Load configured plugins\n    // Validate configuration\n    for (const provider of environment.providers) {\n      await garden.loadPlugin(provider.name, provider)\n    }\n\n    return garden\n  }\n\n  getPluginContext(providerName: string) {\n    return createPluginContext(this, providerName)\n  }\n\n  async clearBuilds() {\n    return this.buildDir.clear()\n  }\n\n  async addTask(task: Task) {\n    await this.taskGraph.addTask(task)\n  }\n\n  async processTasks(): Promise<TaskResults> {\n    return this.taskGraph.processTasks()\n  }\n\n  private registerPlugin(name: string, moduleOrFactory: RegisterPluginParam) {\n    let factory: PluginFactory\n\n    if (typeof moduleOrFactory === \"function\") {\n      factory = moduleOrFactory\n\n    } else if (isString(moduleOrFactory)) {\n      let moduleNameOrLocation = moduleOrFactory\n      const parsedLocation = parse(moduleNameOrLocation)\n\n      // allow relative references to project root\n      if (parse(moduleNameOrLocation).dir !== \"\") {\n        console.log(this.projectRoot)\n        console.log(moduleNameOrLocation)\n        moduleNameOrLocation = resolve(this.projectRoot, moduleNameOrLocation)\n      }\n\n      let pluginModule\n\n      try {\n        pluginModule = require(moduleNameOrLocation)\n      } catch (error) {\n        throw new ConfigurationError(\n          `Unable to load plugin \"${moduleNameOrLocation}\" (could not load module: ${error.message})`, {\n            message: error.message,\n            moduleNameOrLocation,\n          })\n      }\n\n      try {\n        pluginModule = validate(\n          pluginModule,\n          pluginModuleSchema,\n          { context: `plugin module \"${moduleNameOrLocation}\"` },\n        )\n\n        if (pluginModule.name) {\n          name = pluginModule.name\n        } else {\n          if (parsedLocation.name === \"index\") {\n            // use parent directory name\n            name = parsedLocation.dir.split(sep).slice(-1)[0]\n          } else {\n            name = parsedLocation.name\n          }\n        }\n\n        validate(name, joiIdentifier(), { context: `name of plugin \"${moduleNameOrLocation}\"` })\n      } catch (err) {\n        throw new PluginError(`Unable to load plugin: ${err}`, {\n          moduleNameOrLocation,\n          err,\n        })\n      }\n\n      factory = pluginModule.gardenPlugin\n\n    } else {\n      throw new TypeError(`Expected plugin factory function, module name or module path`)\n    }\n\n    this.registeredPlugins[name] = factory\n  }\n\n  private async loadPlugin(pluginName: string, config: object) {\n    const factory = this.registeredPlugins[pluginName]\n\n    if (!factory) {\n      throw new ConfigurationError(`Configured plugin '${pluginName}' has not been registered`, {\n        name: pluginName,\n        availablePlugins: Object.keys(this.registeredPlugins),\n      })\n    }\n\n    let plugin\n\n    try {\n      plugin = await factory({\n        projectName: this.projectName,\n        config,\n        logEntry: this.log,\n      })\n    } catch (error) {\n      throw new PluginError(`Unexpected error when loading plugin \"${pluginName}\": ${error}`, {\n        pluginName,\n        error,\n      })\n    }\n\n    plugin = validate(plugin, pluginSchema, { context: `plugin \"${pluginName}\"` })\n\n    this.loadedPlugins[pluginName] = plugin\n\n    // allow plugins to extend their own config (that gets passed to action handlers)\n    const providerConfig = findByName(this.environment.providers, pluginName)\n    if (providerConfig) {\n      extend(providerConfig, plugin.config, config)\n    } else {\n      this.environment.providers.push(extend({ name: pluginName }, plugin.config, config))\n    }\n\n    for (const modulePath of plugin.modules || []) {\n      let moduleConfig = await this.resolveModule(modulePath)\n      if (!moduleConfig) {\n        throw new PluginError(`Could not load module \"${modulePath}\" specified in plugin \"${pluginName}\"`, {\n          pluginName,\n          modulePath,\n        })\n      }\n      moduleConfig.plugin = pluginName\n      await this.addModule(moduleConfig)\n    }\n\n    const actions = plugin.actions || {}\n\n    for (const actionType of pluginActionNames) {\n      const handler = actions[actionType]\n      handler && this.addActionHandler(pluginName, actionType, handler)\n    }\n\n    const moduleActions = plugin.moduleActions || {}\n\n    for (const moduleType of Object.keys(moduleActions)) {\n      for (const actionType of moduleActionNames) {\n        const handler = moduleActions[moduleType][actionType]\n        handler && this.addModuleActionHandler(pluginName, actionType, moduleType, handler)\n      }\n    }\n  }\n\n  private getPlugin(pluginName: string) {\n    const plugin = this.loadedPlugins[pluginName]\n\n    if (!plugin) {\n      throw new PluginError(`Could not find plugin ${pluginName}. Are you missing a provider configuration?`, {\n        pluginName,\n        availablePlugins: Object.keys(this.loadedPlugins),\n      })\n    }\n\n    return plugin\n  }\n\n  private addActionHandler<T extends keyof PluginActions>(\n    pluginName: string, actionType: T, handler: PluginActions[T],\n  ) {\n    const plugin = this.getPlugin(pluginName)\n    const schema = pluginActionDescriptions[actionType].resultSchema\n\n    const wrapped = async (...args) => {\n      const result = await handler.apply(plugin, args)\n      return validate(result, schema, { context: `${actionType} output from plugin ${pluginName}` })\n    }\n    wrapped[\"actionType\"] = actionType\n    wrapped[\"pluginName\"] = pluginName\n\n    this.actionHandlers[actionType][pluginName] = wrapped\n  }\n\n  private addModuleActionHandler<T extends keyof ModuleActions>(\n    pluginName: string, actionType: T, moduleType: string, handler: ModuleActions[T],\n  ) {\n    const plugin = this.getPlugin(pluginName)\n    const schema = moduleActionDescriptions[actionType].resultSchema\n\n    const wrapped = async (...args) => {\n      const result = await handler.apply(plugin, args)\n      return validate(result, schema, { context: `${actionType} output from plugin ${pluginName}` })\n    }\n    wrapped[\"actionType\"] = actionType\n    wrapped[\"pluginName\"] = pluginName\n    wrapped[\"moduleType\"] = moduleType\n\n    if (!this.moduleActionHandlers[actionType]) {\n      this.moduleActionHandlers[actionType] = {}\n    }\n\n    if (!this.moduleActionHandlers[actionType][moduleType]) {\n      this.moduleActionHandlers[actionType][moduleType] = {}\n    }\n\n    this.moduleActionHandlers[actionType][moduleType][pluginName] = wrapped\n  }\n\n  /*\n    Returns all modules that are registered in this context.\n    Scans for modules in the project root if it hasn't already been done.\n   */\n  async getModules(names?: string[], noScan?: boolean): Promise<Module[]> {\n    if (!this.modulesScanned && !noScan) {\n      await this.scanModules()\n    }\n\n    let configs: ModuleConfig[]\n\n    if (!!names) {\n      configs = []\n      const missing: string[] = []\n\n      for (const name of names) {\n        const module = this.moduleConfigs[name]\n\n        if (!module) {\n          missing.push(name)\n        } else {\n          configs.push(module)\n        }\n      }\n\n      if (missing.length) {\n        throw new ParameterError(`Could not find module(s): ${missing.join(\", \")}`, {\n          missing,\n          available: Object.keys(this.moduleConfigs),\n        })\n      }\n    } else {\n      configs = Object.values(this.moduleConfigs)\n    }\n\n    return Bluebird.map(configs, config => moduleFromConfig(this, config))\n  }\n\n  /**\n   * Returns the module with the specified name. Throws error if it doesn't exist.\n   */\n  async getModule(name: string, noScan?: boolean): Promise<Module> {\n    return (await this.getModules([name], noScan))[0]\n  }\n\n  /**\n   * Given the provided lists of build and service dependencies, return a list of all modules\n   * required to satisfy those dependencies.\n   */\n  async resolveModuleDependencies(buildDependencies: BuildDependencyConfig[], serviceDependencies: string[]) {\n    const buildDeps = await Bluebird.map(buildDependencies, async (dep) => {\n      const moduleKey = getModuleKey(dep.name, dep.plugin)\n      const module = await this.getModule(moduleKey)\n      return [module].concat(await this.resolveModuleDependencies(module.build.dependencies, []))\n    })\n\n    const runtimeDeps = await Bluebird.map(serviceDependencies, async (serviceName) => {\n      const service = await this.getService(serviceName)\n      return this.resolveModuleDependencies(\n        [{ name: service.module.name, copy: [] }],\n        service.config.dependencies || [],\n      )\n    })\n\n    const deps = flatten(buildDeps).concat(flatten(runtimeDeps))\n\n    return sortBy(uniqBy(deps, \"name\"), \"name\")\n  }\n\n  /**\n   * Given a module, and a list of dependencies, resolve the version for that combination of modules.\n   * The combined version is a either the latest dirty module version (if any), or the hash of the module version\n   * and the versions of its dependencies (in sorted order).\n   */\n  async resolveVersion(moduleName: string, moduleDependencies: BuildDependencyConfig[], force = false) {\n    const config = this.moduleConfigs[moduleName]\n    const cacheKey = [\"moduleVersions\", moduleName]\n\n    if (!force) {\n      const cached = <ModuleVersion>this.cache.get(cacheKey)\n\n      if (cached) {\n        return cached\n      }\n    }\n\n    const dependencyKeys = moduleDependencies.map(dep => getModuleKey(dep.name, dep.plugin))\n    const dependencies = Object.values(pickKeys(this.moduleConfigs, dependencyKeys, \"module config\"))\n    const cacheContexts = dependencies.concat([config]).map(c => getModuleCacheContext(c))\n\n    const version = await this.vcs.resolveVersion(config, dependencies)\n\n    this.cache.set(cacheKey, version, ...cacheContexts)\n    return version\n  }\n\n  /*\n    Returns all services that are registered in this context, or the ones specified.\n    Scans for modules and services in the project root if it hasn't already been done.\n   */\n  async getServices(names?: string[], noScan?: boolean): Promise<Service[]> {\n    if (!this.modulesScanned && !noScan) {\n      await this.scanModules()\n    }\n\n    const picked = names ? pickKeys(this.serviceNameIndex, names, \"service\") : this.serviceNameIndex\n\n    return Bluebird.map(Object.entries(picked), async ([serviceName, moduleName]) => {\n      const module = await this.getModule(moduleName)\n      const config = findByName(module.serviceConfigs, serviceName)!\n\n      return {\n        name: serviceName,\n        config,\n        module,\n        spec: config.spec,\n      }\n    })\n  }\n\n  /**\n   * Returns the service with the specified name. Throws error if it doesn't exist.\n   */\n  async getService(name: string, noScan?: boolean): Promise<Service<Module>> {\n    return (await this.getServices([name], noScan))[0]\n  }\n\n  /*\n    Scans the project root for modules and adds them to the context.\n   */\n  async scanModules(force = false) {\n    return scanLock.acquire(\"scan-modules\", async () => {\n      if (this.modulesScanned && !force) {\n        return\n      }\n\n      let extSourcePaths: string[] = []\n\n      // Add external sources that are defined at the project level. External sources are either kept in\n      // the .garden/sources dir (and cloned there if needed), or they're linked to a local path via the link command.\n      for (const { name, repositoryUrl } of this.projectSources) {\n        const path = await this.loadExtSourcePath({ name, repositoryUrl, sourceType: \"project\" })\n        extSourcePaths.push(path)\n      }\n\n      const dirsToScan = [this.projectRoot, ...extSourcePaths]\n\n      const modulePaths = flatten(await Bluebird.map(dirsToScan, async dir => {\n        const ignorer = await getIgnorer(dir)\n        const scanOpts = {\n          filter: (path) => {\n            const relPath = relative(this.projectRoot, path)\n            return !ignorer.ignores(relPath)\n          },\n        }\n        const paths: string[] = []\n\n        for await (const item of scanDirectory(dir, scanOpts)) {\n          if (!item) {\n            continue\n          }\n\n          const parsedPath = parse(item.path)\n\n          if (parsedPath.base !== MODULE_CONFIG_FILENAME) {\n            continue\n          }\n\n          paths.push(parsedPath.dir)\n        }\n\n        return paths\n      })).filter(Boolean)\n\n      await Bluebird.map(modulePaths, async path => {\n        const config = await this.resolveModule(path)\n        config && await this.addModule(config)\n      })\n\n      this.modulesScanned = true\n\n      await this.detectCircularDependencies()\n\n      const moduleConfigContext = new ModuleConfigContext(\n        this, this.environment, Object.values(this.moduleConfigs),\n      )\n      this.moduleConfigs = await resolveTemplateStrings(this.moduleConfigs, moduleConfigContext)\n    })\n  }\n\n  private async detectCircularDependencies() {\n    const modules = await this.getModules()\n    const services = await this.getServices()\n\n    return detectCircularDependencies(modules, services)\n  }\n\n  /*\n    Adds the specified module to the context\n\n    @param force - add the module again, even if it's already registered\n   */\n  async addModule(config: ModuleConfig, force = false) {\n    const validateHandler = await this.getModuleActionHandler({ actionType: \"validate\", moduleType: config.type })\n    const ctx = this.getPluginContext(validateHandler[\"pluginName\"])\n\n    config = await validateHandler({ ctx, moduleConfig: config })\n\n    // FIXME: this is rather clumsy\n    config.name = getModuleKey(config.name, config.plugin)\n\n    if (!force && this.moduleConfigs[config.name]) {\n      const pathA = relative(this.projectRoot, this.moduleConfigs[config.name].path)\n      const pathB = relative(this.projectRoot, config.path)\n\n      throw new ConfigurationError(\n        `Module ${config.name} is declared multiple times ('${pathA}' and '${pathB}')`,\n        { pathA, pathB },\n      )\n    }\n\n    this.moduleConfigs[config.name] = config\n\n    // Add to service-module map\n    for (const serviceConfig of config.serviceConfigs) {\n      const serviceName = serviceConfig.name\n\n      if (!force && this.serviceNameIndex[serviceName]) {\n        throw new ConfigurationError(\n          `Service names must be unique - ${serviceName} is declared multiple times ` +\n          `(in '${this.serviceNameIndex[serviceName]}' and '${config.name}')`,\n          {\n            serviceName,\n            moduleA: this.serviceNameIndex[serviceName],\n            moduleB: config.name,\n          },\n        )\n      }\n\n      this.serviceNameIndex[serviceName] = config.name\n    }\n\n    if (this.modulesScanned) {\n      // need to re-run this if adding modules after initial scan\n      await this.detectCircularDependencies()\n    }\n  }\n\n  /*\n    Maps the provided name or locator to a Module. We first look for a module in the\n    project with the provided name. If it does not exist, we treat it as a path\n    (resolved with the project path as a base path) and attempt to load the module\n    from there.\n   */\n  async resolveModule(nameOrLocation: string): Promise<ModuleConfig | null> {\n    const parsedPath = parse(nameOrLocation)\n\n    if (parsedPath.dir === \"\") {\n      // Looks like a name\n      const existingModule = this.moduleConfigs[nameOrLocation]\n\n      if (!existingModule) {\n        throw new ConfigurationError(`Module ${nameOrLocation} could not be found`, {\n          name: nameOrLocation,\n        })\n      }\n\n      return existingModule\n    }\n\n    // Looks like a path\n    const path = resolve(this.projectRoot, nameOrLocation)\n    const config = await loadConfig(this.projectRoot, path)\n\n    if (!config || !config.module) {\n      return null\n    }\n\n    const moduleConfig = cloneDeep(config.module)\n\n    if (moduleConfig.repositoryUrl) {\n      moduleConfig.path = await this.loadExtSourcePath({\n        name: moduleConfig.name,\n        repositoryUrl: moduleConfig.repositoryUrl,\n        sourceType: \"module\",\n      })\n    }\n\n    return moduleConfig\n  }\n\n  //===========================================================================\n  //region Internal helpers\n  //===========================================================================\n\n  /**\n   * Clones the project/module source if needed and returns the path (either from .garden/sources or from a local path)\n   */\n  public async loadExtSourcePath({ name, repositoryUrl, sourceType }: {\n    name: string,\n    repositoryUrl: string,\n    sourceType: ExternalSourceType,\n  }): Promise<string> {\n\n    const linkedSources = await getLinkedSources(this, sourceType)\n\n    const linked = findByName(linkedSources, name)\n\n    if (linked) {\n      return linked.path\n    }\n\n    const path = await this.vcs.ensureRemoteSource({ name, sourceType, url: repositoryUrl, logEntry: this.log })\n\n    return path\n  }\n\n  /**\n   * Get a handler for the specified action.\n   */\n  public getActionHandlers<T extends keyof PluginActions>(actionType: T, pluginName?: string): ActionHandlerMap<T> {\n    return this.filterActionHandlers(this.actionHandlers[actionType], pluginName)\n  }\n\n  /**\n   * Get a handler for the specified module action.\n   */\n  public getModuleActionHandlers<T extends keyof ModuleAndServiceActions>(\n    { actionType, moduleType, pluginName }:\n      { actionType: T, moduleType: string, pluginName?: string },\n  ): ModuleActionHandlerMap<T> {\n    return this.filterActionHandlers((this.moduleActionHandlers[actionType] || {})[moduleType], pluginName)\n  }\n\n  private filterActionHandlers(handlers, pluginName?: string) {\n    // make sure plugin is loaded\n    if (!!pluginName) {\n      this.getPlugin(pluginName)\n    }\n\n    if (handlers === undefined) {\n      handlers = {}\n    }\n\n    return !pluginName ? handlers : pickBy(handlers, (handler) => handler[\"pluginName\"] === pluginName)\n  }\n\n  /**\n   * Get the last configured handler for the specified action (and optionally module type).\n   */\n  public getActionHandler<T extends keyof PluginActions>(\n    { actionType, pluginName, defaultHandler }:\n      { actionType: T, pluginName?: string, defaultHandler?: PluginActions[T] },\n  ): PluginActions[T] {\n\n    const handlers = Object.values(this.getActionHandlers(actionType, pluginName))\n\n    if (handlers.length) {\n      return handlers[handlers.length - 1]\n    } else if (defaultHandler) {\n      defaultHandler[\"pluginName\"] = defaultProvider.name\n      return defaultHandler\n    }\n\n    const errorDetails = {\n      requestedHandlerType: actionType,\n      environment: this.environment.name,\n      pluginName,\n    }\n\n    if (pluginName) {\n      throw new PluginError(`Plugin '${pluginName}' does not have a '${actionType}' handler.`, errorDetails)\n    } else {\n      throw new ParameterError(\n        `No '${actionType}' handler configured in environment '${this.environment.name}'. ` +\n        `Are you missing a provider configuration?`,\n        errorDetails,\n      )\n    }\n  }\n\n  /**\n   * Get the last configured handler for the specified action.\n   */\n  public getModuleActionHandler<T extends keyof ModuleAndServiceActions>(\n    { actionType, moduleType, pluginName, defaultHandler }:\n      { actionType: T, moduleType: string, pluginName?: string, defaultHandler?: ModuleAndServiceActions[T] },\n  ): ModuleAndServiceActions[T] {\n\n    const handlers = Object.values(this.getModuleActionHandlers({ actionType, moduleType, pluginName }))\n\n    if (handlers.length) {\n      return handlers[handlers.length - 1]\n    } else if (defaultHandler) {\n      defaultHandler[\"pluginName\"] = defaultProvider.name\n      return defaultHandler\n    }\n\n    const errorDetails = {\n      requestedHandlerType: actionType,\n      requestedModuleType: moduleType,\n      environment: this.environment.name,\n      pluginName,\n    }\n\n    if (pluginName) {\n      throw new PluginError(\n        `Plugin '${pluginName}' does not have a '${actionType}' handler for module type '${moduleType}'.`,\n        errorDetails,\n      )\n    } else {\n      throw new ParameterError(\n        `No '${actionType}' handler configured for module type '${moduleType}' in environment ` +\n        `'${this.environment.name}'. Are you missing a provider configuration?`,\n        errorDetails,\n      )\n    }\n  }\n\n  //endregion\n}\n"]} diff --git a/garden-service/build/index.d.ts b/garden-service/build/index.d.ts new file mode 100644 index 00000000000..ad95451ac4d --- /dev/null +++ b/garden-service/build/index.d.ts @@ -0,0 +1,2 @@ +declare const cli: any; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/garden-service/build/index.js b/garden-service/build/index.js new file mode 100644 index 00000000000..20db0a94200 --- /dev/null +++ b/garden-service/build/index.js @@ -0,0 +1,11 @@ +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +const cli = require("./cli/cli"); +cli.run(); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE1BQU0sR0FBRyxHQUFHLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQTtBQUVoQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUEiLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChDKSAyMDE4IEdhcmRlbiBUZWNobm9sb2dpZXMsIEluYy4gPGluZm9AZ2FyZGVuLmlvPlxuICpcbiAqIFRoaXMgU291cmNlIENvZGUgRm9ybSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGUgTW96aWxsYSBQdWJsaWNcbiAqIExpY2Vuc2UsIHYuIDIuMC4gSWYgYSBjb3B5IG9mIHRoZSBNUEwgd2FzIG5vdCBkaXN0cmlidXRlZCB3aXRoIHRoaXNcbiAqIGZpbGUsIFlvdSBjYW4gb2J0YWluIG9uZSBhdCBodHRwOi8vbW96aWxsYS5vcmcvTVBMLzIuMC8uXG4gKi9cblxuY29uc3QgY2xpID0gcmVxdWlyZShcIi4vY2xpL2NsaVwiKVxuXG5jbGkucnVuKClcbiJdfQ== diff --git a/garden-service/build/logger/log-entry.d.ts b/garden-service/build/logger/log-entry.d.ts new file mode 100644 index 00000000000..8cf3cb274fa --- /dev/null +++ b/garden-service/build/logger/log-entry.d.ts @@ -0,0 +1,47 @@ +import * as logSymbols from "log-symbols"; +import * as nodeEmoji from "node-emoji"; +import { LogNode, LogLevel } from "./log-node"; +import { GardenError } from "../exceptions"; +import { Omit } from "../util/util"; +export declare type EmojiName = keyof typeof nodeEmoji.emoji; +export declare type LogSymbol = keyof typeof logSymbols | "empty"; +export declare type EntryStatus = "active" | "done" | "error" | "success" | "warn"; +export interface UpdateOpts { + msg?: string | string[]; + section?: string; + emoji?: EmojiName; + symbol?: LogSymbol; + append?: boolean; + fromStdStream?: boolean; + showDuration?: boolean; + error?: GardenError; + status?: EntryStatus; + indentationLevel?: number; +} +export interface CreateOpts extends UpdateOpts { + id?: string; +} +export declare type CreateParam = string | CreateOpts; +export interface LogEntryConstructor { + level: LogLevel; + opts: CreateOpts; + parent: LogNode; +} +export declare function resolveParam(param?: string | T): T; +export declare class LogEntry extends LogNode { + opts: UpdateOpts; + constructor({ level, opts, parent }: LogEntryConstructor); + private setOwnState; + private deepSetState; + createNode(level: LogLevel, parent: LogNode, param?: CreateParam): LogEntry; + setState(param?: string | UpdateOpts): LogEntry; + setDone(param?: string | Omit): LogEntry; + setSuccess(param?: string | Omit): LogEntry; + setError(param?: string | Omit): LogEntry; + setWarn(param?: string | Omit): LogEntry; + fromStdStream(): boolean; + stop(): this; + inspect(): void; + filterBySection(section: string): LogEntry[]; +} +//# sourceMappingURL=log-entry.d.ts.map \ No newline at end of file diff --git a/garden-service/build/logger/log-entry.js b/garden-service/build/logger/log-entry.js new file mode 100644 index 00000000000..663019cd26a --- /dev/null +++ b/garden-service/build/logger/log-entry.js @@ -0,0 +1,125 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0) + t[p[i]] = s[p[i]]; + return t; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const log_node_1 = require("./log-node"); +const util_1 = require("./util"); +// TODO Fix any cast +function resolveParam(param) { + return typeof param === "string" ? { msg: param } : param || {}; +} +exports.resolveParam = resolveParam; +class LogEntry extends log_node_1.LogNode { + constructor({ level, opts, parent }) { + const { id } = opts, otherOpts = __rest(opts, ["id"]); + super(level, parent, id); + this.opts = otherOpts; + if (this.level === log_node_1.LogLevel.error) { + this.opts.status = "error"; + } + } + setOwnState(nextOpts) { + let msg; + const { append, msg: nextMsg } = nextOpts; + const prevMsg = this.opts.msg; + if (prevMsg !== undefined && nextMsg && append) { + msg = lodash_1.flatten([...[prevMsg], ...[nextMsg]]); + } + else if (nextMsg) { + msg = nextMsg; + } + else { + msg = prevMsg; + } + // Hack to preserve section alignment if symbols or spinners disappear + const hadSymbolOrSpinner = this.opts.symbol || this.opts.status === "active"; + const hasSymbolOrSpinner = nextOpts.symbol || nextOpts.status === "active"; + if (this.opts.section && hadSymbolOrSpinner && !hasSymbolOrSpinner) { + nextOpts.symbol = "empty"; + } + this.opts = Object.assign({}, this.opts, nextOpts, { msg }); + } + // Update node and child nodes + deepSetState(opts) { + const wasActive = this.opts.status === "active"; + this.setOwnState(opts); + // Stop active child nodes if parent is no longer active + if (wasActive && this.opts.status !== "active") { + util_1.getChildEntries(this).forEach(entry => { + if (entry.opts.status === "active") { + entry.setOwnState({ status: "done" }); + } + }); + } + } + createNode(level, parent, param) { + // Empty entries inherit their parent's indentation level + let { indentationLevel } = this.opts; + if (param) { + indentationLevel = (indentationLevel || 0) + 1; + } + const opts = Object.assign({ indentationLevel }, resolveParam(param)); + return new LogEntry({ level, opts, parent }); + } + // Preserves status + setState(param) { + this.deepSetState(Object.assign({}, resolveParam(param), { status: this.opts.status })); + this.root.onGraphChange(this); + return this; + } + setDone(param) { + this.deepSetState(Object.assign({}, resolveParam(param), { status: "done" })); + this.root.onGraphChange(this); + return this; + } + setSuccess(param) { + this.deepSetState(Object.assign({}, resolveParam(param), { symbol: "success", status: "success" })); + this.root.onGraphChange(this); + return this; + } + setError(param) { + this.deepSetState(Object.assign({}, resolveParam(param), { symbol: "error", status: "error" })); + this.root.onGraphChange(this); + return this; + } + setWarn(param) { + this.deepSetState(Object.assign({}, resolveParam(param), { symbol: "warning", status: "warn" })); + this.root.onGraphChange(this); + return this; + } + fromStdStream() { + return !!this.opts.fromStdStream; + } + stop() { + // Stop gracefully if still in active state + if (this.opts.status === "active") { + this.setOwnState({ symbol: "empty", status: "done" }); + this.root.onGraphChange(this); + } + return this; + } + inspect() { + console.log(JSON.stringify(Object.assign({}, this.opts, { level: this.level, children: this.children }))); + } + filterBySection(section) { + return util_1.getChildEntries(this).filter(entry => entry.opts.section === section); + } +} +exports.LogEntry = LogEntry; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["logger/log-entry.ts"],"names":[],"mappings":"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","file":"logger/log-entry.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as logSymbols from \"log-symbols\"\nimport * as nodeEmoji from \"node-emoji\"\nimport { flatten } from \"lodash\"\n\nimport { LogNode, LogLevel } from \"./log-node\"\nimport { getChildEntries } from \"./util\"\nimport { GardenError } from \"../exceptions\"\nimport { Omit } from \"../util/util\"\n\nexport type EmojiName = keyof typeof nodeEmoji.emoji\nexport type LogSymbol = keyof typeof logSymbols | \"empty\"\nexport type EntryStatus = \"active\" | \"done\" | \"error\" | \"success\" | \"warn\"\n\nexport interface UpdateOpts {\n  msg?: string | string[]\n  section?: string\n  emoji?: EmojiName\n  symbol?: LogSymbol\n  append?: boolean\n  fromStdStream?: boolean\n  showDuration?: boolean\n  error?: GardenError\n  status?: EntryStatus\n  indentationLevel?: number\n}\n\nexport interface CreateOpts extends UpdateOpts {\n  id?: string\n}\n\nexport type CreateParam = string | CreateOpts\n\nexport interface LogEntryConstructor {\n  level: LogLevel\n  opts: CreateOpts\n  parent: LogNode\n}\n\n// TODO Fix any cast\nexport function resolveParam<T extends UpdateOpts>(param?: string | T): T {\n  return typeof param === \"string\" ? <any>{ msg: param } : param || {}\n}\n\nexport class LogEntry extends LogNode {\n  public opts: UpdateOpts\n\n  constructor({ level, opts, parent }: LogEntryConstructor) {\n    const { id, ...otherOpts } = opts\n    super(level, parent, id)\n    this.opts = otherOpts\n    if (this.level === LogLevel.error) {\n      this.opts.status = \"error\"\n    }\n  }\n\n  private setOwnState(nextOpts: UpdateOpts): void {\n    let msg: string | string[] | undefined\n    const { append, msg: nextMsg } = nextOpts\n    const prevMsg = this.opts.msg\n    if (prevMsg !== undefined && nextMsg && append) {\n      msg = flatten([...[prevMsg], ...[nextMsg]])\n    } else if (nextMsg) {\n      msg = nextMsg\n    } else {\n      msg = prevMsg\n    }\n\n    // Hack to preserve section alignment if symbols or spinners disappear\n    const hadSymbolOrSpinner = this.opts.symbol || this.opts.status === \"active\"\n    const hasSymbolOrSpinner = nextOpts.symbol || nextOpts.status === \"active\"\n    if (this.opts.section && hadSymbolOrSpinner && !hasSymbolOrSpinner) {\n      nextOpts.symbol = \"empty\"\n    }\n\n    this.opts = { ...this.opts, ...nextOpts, msg }\n  }\n\n  //  Update node and child nodes\n  private deepSetState(opts: UpdateOpts): void {\n    const wasActive = this.opts.status === \"active\"\n\n    this.setOwnState(opts)\n\n    // Stop active child nodes if parent is no longer active\n    if (wasActive && this.opts.status !== \"active\") {\n      getChildEntries(this).forEach(entry => {\n        if (entry.opts.status === \"active\") {\n          entry.setOwnState({ status: \"done\" })\n        }\n      })\n    }\n  }\n\n  createNode(level: LogLevel, parent: LogNode, param?: CreateParam) {\n    // Empty entries inherit their parent's indentation level\n    let { indentationLevel } = this.opts\n    if (param) {\n      indentationLevel = (indentationLevel || 0) + 1\n    }\n    const opts = {\n      indentationLevel,\n      ...resolveParam(param),\n    }\n    return new LogEntry({ level, opts, parent })\n  }\n\n  // Preserves status\n  setState(param?: string | UpdateOpts): LogEntry {\n    this.deepSetState({ ...resolveParam(param), status: this.opts.status })\n    this.root.onGraphChange(this)\n    return this\n  }\n\n  setDone(param?: string | Omit<UpdateOpts, \"status\">): LogEntry {\n    this.deepSetState({ ...resolveParam(param), status: \"done\" })\n    this.root.onGraphChange(this)\n    return this\n  }\n\n  setSuccess(param?: string | Omit<UpdateOpts, \"status\" & \"symbol\">): LogEntry {\n    this.deepSetState({ ...resolveParam(param), symbol: \"success\", status: \"success\" })\n    this.root.onGraphChange(this)\n    return this\n  }\n\n  setError(param?: string | Omit<UpdateOpts, \"status\" & \"symbol\">): LogEntry {\n    this.deepSetState({ ...resolveParam(param), symbol: \"error\", status: \"error\" })\n    this.root.onGraphChange(this)\n    return this\n  }\n\n  setWarn(param?: string | Omit<UpdateOpts, \"status\" & \"symbol\">): LogEntry {\n    this.deepSetState({ ...resolveParam(param), symbol: \"warning\", status: \"warn\" })\n    this.root.onGraphChange(this)\n    return this\n  }\n\n  fromStdStream(): boolean {\n    return !!this.opts.fromStdStream\n  }\n\n  stop() {\n    // Stop gracefully if still in active state\n    if (this.opts.status === \"active\") {\n      this.setOwnState({ symbol: \"empty\", status: \"done\" })\n      this.root.onGraphChange(this)\n    }\n    return this\n  }\n\n  inspect() {\n    console.log(JSON.stringify({\n      ...this.opts,\n      level: this.level,\n      children: this.children,\n    }))\n  }\n\n  filterBySection(section: string): LogEntry[] {\n    return getChildEntries(this).filter(entry => entry.opts.section === section)\n  }\n\n}\n"]} diff --git a/garden-service/build/logger/log-node.d.ts b/garden-service/build/logger/log-node.d.ts new file mode 100644 index 00000000000..23d62f55c21 --- /dev/null +++ b/garden-service/build/logger/log-node.d.ts @@ -0,0 +1,36 @@ +import { LogEntry, CreateParam } from "./log-entry"; +export declare enum LogLevel { + error = 0, + warn = 1, + info = 2, + verbose = 3, + debug = 4, + silly = 5 +} +export declare abstract class LogNode { + readonly level: LogLevel; + readonly parent?: LogNode | undefined; + readonly id?: string | undefined; + readonly timestamp: number; + readonly key: string; + readonly children: T[]; + readonly root: RootLogNode; + constructor(level: LogLevel, parent?: LogNode | undefined, id?: string | undefined); + abstract createNode(level: LogLevel, parent: LogNode, param?: U): T; + protected appendNode(level: LogLevel, param?: U): T; + silly(param?: U): T; + debug(param?: U): T; + verbose(param?: U): T; + info(param?: U): T; + warn(param?: U): T; + error(param?: U): T; + /** + * Returns the duration in seconds, defaults to 2 decimal precision + */ + getDuration(precision?: number): number; +} +export declare abstract class RootLogNode extends LogNode { + abstract onGraphChange(node: T): void; + findById(id: string): T | void; +} +//# sourceMappingURL=log-node.d.ts.map \ No newline at end of file diff --git a/garden-service/build/logger/log-node.js b/garden-service/build/logger/log-node.js new file mode 100644 index 00000000000..9340b29da3d --- /dev/null +++ b/garden-service/build/logger/log-node.js @@ -0,0 +1,77 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const uniqid = require("uniqid"); +const lodash_1 = require("lodash"); +const util_1 = require("./util"); +var LogLevel; +(function (LogLevel) { + LogLevel[LogLevel["error"] = 0] = "error"; + LogLevel[LogLevel["warn"] = 1] = "warn"; + LogLevel[LogLevel["info"] = 2] = "info"; + LogLevel[LogLevel["verbose"] = 3] = "verbose"; + LogLevel[LogLevel["debug"] = 4] = "debug"; + LogLevel[LogLevel["silly"] = 5] = "silly"; +})(LogLevel = exports.LogLevel || (exports.LogLevel = {})); +class LogNode { + constructor(level, parent, id) { + this.level = level; + this.parent = parent; + this.id = id; + if (this instanceof RootLogNode) { + this.root = this; + } + else { + // Non-root nodes have a parent + this.root = parent.root; + } + this.key = uniqid(); + this.timestamp = Date.now(); + this.children = []; + } + appendNode(level, param) { + const node = this.createNode(level, this, param); + this.children.push(node); + this.root.onGraphChange(node); + return node; + } + silly(param) { + return this.appendNode(LogLevel.silly, param); + } + debug(param) { + return this.appendNode(LogLevel.debug, param); + } + verbose(param) { + return this.appendNode(LogLevel.verbose, param); + } + info(param) { + return this.appendNode(LogLevel.info, param); + } + warn(param) { + return this.appendNode(LogLevel.warn, param); + } + error(param) { + return this.appendNode(LogLevel.error, param); + } + /** + * Returns the duration in seconds, defaults to 2 decimal precision + */ + getDuration(precision = 2) { + return lodash_1.round((Date.now() - this.timestamp) / 1000, precision); + } +} +exports.LogNode = LogNode; +class RootLogNode extends LogNode { + findById(id) { + return util_1.findLogNode(this, node => node.id === id); + } +} +exports.RootLogNode = RootLogNode; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxvZ2dlci9sb2ctbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOztBQUVILGlDQUFnQztBQUNoQyxtQ0FBOEI7QUFFOUIsaUNBQW9DO0FBR3BDLElBQVksUUFPWDtBQVBELFdBQVksUUFBUTtJQUNsQix5Q0FBUyxDQUFBO0lBQ1QsdUNBQVEsQ0FBQTtJQUNSLHVDQUFRLENBQUE7SUFDUiw2Q0FBVyxDQUFBO0lBQ1gseUNBQVMsQ0FBQTtJQUNULHlDQUFTLENBQUE7QUFDWCxDQUFDLEVBUFcsUUFBUSxHQUFSLGdCQUFRLEtBQVIsZ0JBQVEsUUFPbkI7QUFFRCxNQUFzQixPQUFPO0lBTTNCLFlBQ2tCLEtBQWUsRUFDZixNQUFtQixFQUNuQixFQUFXO1FBRlgsVUFBSyxHQUFMLEtBQUssQ0FBVTtRQUNmLFdBQU0sR0FBTixNQUFNLENBQWE7UUFDbkIsT0FBRSxHQUFGLEVBQUUsQ0FBUztRQUUzQixJQUFJLElBQUksWUFBWSxXQUFXLEVBQUU7WUFDL0IsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUE7U0FDakI7YUFBTTtZQUNMLCtCQUErQjtZQUMvQixJQUFJLENBQUMsSUFBSSxHQUFHLE1BQU8sQ0FBQyxJQUFJLENBQUE7U0FDekI7UUFDRCxJQUFJLENBQUMsR0FBRyxHQUFHLE1BQU0sRUFBRSxDQUFBO1FBQ25CLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFBO1FBQzNCLElBQUksQ0FBQyxRQUFRLEdBQUcsRUFBRSxDQUFBO0lBQ3BCLENBQUM7SUFJUyxVQUFVLENBQUMsS0FBZSxFQUFFLEtBQVM7UUFDN0MsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxLQUFLLEVBQUUsSUFBSSxFQUFFLEtBQUssQ0FBQyxDQUFBO1FBQ2hELElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFBO1FBQ3hCLElBQUksQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxDQUFBO1FBQzdCLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztJQUVELEtBQUssQ0FBQyxLQUFTO1FBQ2IsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDL0MsQ0FBQztJQUVELEtBQUssQ0FBQyxLQUFTO1FBQ2IsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDL0MsQ0FBQztJQUVELE9BQU8sQ0FBQyxLQUFTO1FBQ2YsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxPQUFPLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDakQsQ0FBQztJQUVELElBQUksQ0FBQyxLQUFTO1FBQ1osT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDOUMsQ0FBQztJQUVELElBQUksQ0FBQyxLQUFTO1FBQ1osT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDOUMsQ0FBQztJQUVELEtBQUssQ0FBQyxLQUFTO1FBQ2IsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDL0MsQ0FBQztJQUVEOztPQUVHO0lBQ0gsV0FBVyxDQUFDLFlBQW9CLENBQUM7UUFDL0IsT0FBTyxjQUFLLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLElBQUksRUFBRSxTQUFTLENBQUMsQ0FBQTtJQUMvRCxDQUFDO0NBRUY7QUE5REQsMEJBOERDO0FBRUQsTUFBc0IsV0FBMEIsU0FBUSxPQUFVO0lBR2hFLFFBQVEsQ0FBQyxFQUFVO1FBQ2pCLE9BQU8sa0JBQVcsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFBO0lBQ2xELENBQUM7Q0FFRjtBQVBELGtDQU9DIiwiZmlsZSI6ImxvZ2dlci9sb2ctbm9kZS5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKEMpIDIwMTggR2FyZGVuIFRlY2hub2xvZ2llcywgSW5jLiA8aW5mb0BnYXJkZW4uaW8+XG4gKlxuICogVGhpcyBTb3VyY2UgQ29kZSBGb3JtIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoZSBNb3ppbGxhIFB1YmxpY1xuICogTGljZW5zZSwgdi4gMi4wLiBJZiBhIGNvcHkgb2YgdGhlIE1QTCB3YXMgbm90IGRpc3RyaWJ1dGVkIHdpdGggdGhpc1xuICogZmlsZSwgWW91IGNhbiBvYnRhaW4gb25lIGF0IGh0dHA6Ly9tb3ppbGxhLm9yZy9NUEwvMi4wLy5cbiAqL1xuXG5pbXBvcnQgKiBhcyB1bmlxaWQgZnJvbSBcInVuaXFpZFwiXG5pbXBvcnQgeyByb3VuZCB9IGZyb20gXCJsb2Rhc2hcIlxuXG5pbXBvcnQgeyBmaW5kTG9nTm9kZSB9IGZyb20gXCIuL3V0aWxcIlxuaW1wb3J0IHsgTG9nRW50cnksIENyZWF0ZVBhcmFtIH0gZnJvbSBcIi4vbG9nLWVudHJ5XCJcblxuZXhwb3J0IGVudW0gTG9nTGV2ZWwge1xuICBlcnJvciA9IDAsXG4gIHdhcm4gPSAxLFxuICBpbmZvID0gMixcbiAgdmVyYm9zZSA9IDMsXG4gIGRlYnVnID0gNCxcbiAgc2lsbHkgPSA1LFxufVxuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgTG9nTm9kZTxUID0gTG9nRW50cnksIFUgPSBDcmVhdGVQYXJhbT4ge1xuICBwdWJsaWMgcmVhZG9ubHkgdGltZXN0YW1wOiBudW1iZXJcbiAgcHVibGljIHJlYWRvbmx5IGtleTogc3RyaW5nXG4gIHB1YmxpYyByZWFkb25seSBjaGlsZHJlbjogVFtdXG4gIHB1YmxpYyByZWFkb25seSByb290OiBSb290TG9nTm9kZTxUPlxuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyByZWFkb25seSBsZXZlbDogTG9nTGV2ZWwsXG4gICAgcHVibGljIHJlYWRvbmx5IHBhcmVudD86IExvZ05vZGU8VD4sXG4gICAgcHVibGljIHJlYWRvbmx5IGlkPzogc3RyaW5nLFxuICApIHtcbiAgICBpZiAodGhpcyBpbnN0YW5jZW9mIFJvb3RMb2dOb2RlKSB7XG4gICAgICB0aGlzLnJvb3QgPSB0aGlzXG4gICAgfSBlbHNlIHtcbiAgICAgIC8vIE5vbi1yb290IG5vZGVzIGhhdmUgYSBwYXJlbnRcbiAgICAgIHRoaXMucm9vdCA9IHBhcmVudCEucm9vdFxuICAgIH1cbiAgICB0aGlzLmtleSA9IHVuaXFpZCgpXG4gICAgdGhpcy50aW1lc3RhbXAgPSBEYXRlLm5vdygpXG4gICAgdGhpcy5jaGlsZHJlbiA9IFtdXG4gIH1cblxuICBhYnN0cmFjdCBjcmVhdGVOb2RlKGxldmVsOiBMb2dMZXZlbCwgcGFyZW50OiBMb2dOb2RlPFQsIFU+LCBwYXJhbT86IFUpOiBUXG5cbiAgcHJvdGVjdGVkIGFwcGVuZE5vZGUobGV2ZWw6IExvZ0xldmVsLCBwYXJhbT86IFUpOiBUIHtcbiAgICBjb25zdCBub2RlID0gdGhpcy5jcmVhdGVOb2RlKGxldmVsLCB0aGlzLCBwYXJhbSlcbiAgICB0aGlzLmNoaWxkcmVuLnB1c2gobm9kZSlcbiAgICB0aGlzLnJvb3Qub25HcmFwaENoYW5nZShub2RlKVxuICAgIHJldHVybiBub2RlXG4gIH1cblxuICBzaWxseShwYXJhbT86IFUpOiBUIHtcbiAgICByZXR1cm4gdGhpcy5hcHBlbmROb2RlKExvZ0xldmVsLnNpbGx5LCBwYXJhbSlcbiAgfVxuXG4gIGRlYnVnKHBhcmFtPzogVSk6IFQge1xuICAgIHJldHVybiB0aGlzLmFwcGVuZE5vZGUoTG9nTGV2ZWwuZGVidWcsIHBhcmFtKVxuICB9XG5cbiAgdmVyYm9zZShwYXJhbT86IFUpOiBUIHtcbiAgICByZXR1cm4gdGhpcy5hcHBlbmROb2RlKExvZ0xldmVsLnZlcmJvc2UsIHBhcmFtKVxuICB9XG5cbiAgaW5mbyhwYXJhbT86IFUpOiBUIHtcbiAgICByZXR1cm4gdGhpcy5hcHBlbmROb2RlKExvZ0xldmVsLmluZm8sIHBhcmFtKVxuICB9XG5cbiAgd2FybihwYXJhbT86IFUpOiBUIHtcbiAgICByZXR1cm4gdGhpcy5hcHBlbmROb2RlKExvZ0xldmVsLndhcm4sIHBhcmFtKVxuICB9XG5cbiAgZXJyb3IocGFyYW0/OiBVKTogVCB7XG4gICAgcmV0dXJuIHRoaXMuYXBwZW5kTm9kZShMb2dMZXZlbC5lcnJvciwgcGFyYW0pXG4gIH1cblxuICAvKipcbiAgICogUmV0dXJucyB0aGUgZHVyYXRpb24gaW4gc2Vjb25kcywgZGVmYXVsdHMgdG8gMiBkZWNpbWFsIHByZWNpc2lvblxuICAgKi9cbiAgZ2V0RHVyYXRpb24ocHJlY2lzaW9uOiBudW1iZXIgPSAyKTogbnVtYmVyIHtcbiAgICByZXR1cm4gcm91bmQoKERhdGUubm93KCkgLSB0aGlzLnRpbWVzdGFtcCkgLyAxMDAwLCBwcmVjaXNpb24pXG4gIH1cblxufVxuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgUm9vdExvZ05vZGU8VCA9IExvZ0VudHJ5PiBleHRlbmRzIExvZ05vZGU8VD4ge1xuICBhYnN0cmFjdCBvbkdyYXBoQ2hhbmdlKG5vZGU6IFQpOiB2b2lkXG5cbiAgZmluZEJ5SWQoaWQ6IHN0cmluZyk6IFQgfCB2b2lkIHtcbiAgICByZXR1cm4gZmluZExvZ05vZGUodGhpcywgbm9kZSA9PiBub2RlLmlkID09PSBpZClcbiAgfVxuXG59XG4iXX0= diff --git a/garden-service/build/logger/logger.d.ts b/garden-service/build/logger/logger.d.ts new file mode 100644 index 00000000000..2028ab72b27 --- /dev/null +++ b/garden-service/build/logger/logger.d.ts @@ -0,0 +1,37 @@ +import { RootLogNode, LogNode } from "./log-node"; +import { LogEntry, CreateOpts } from "./log-entry"; +import { Writer } from "./writers/base"; +import { LogLevel } from "./log-node"; +export declare enum LoggerType { + quiet = "quiet", + basic = "basic", + fancy = "fancy" +} +export declare function getCommonConfig(loggerType: LoggerType): LoggerConfig; +export interface LoggerConfig { + level: LogLevel; + writers?: Writer[]; +} +export declare class Logger extends RootLogNode { + writers: Writer[]; + private static instance; + static getInstance(): Logger; + static initialize(config: LoggerConfig): any; + private constructor(); + createNode(level: LogLevel, _parent: LogNode, opts: CreateOpts): any; + onGraphChange(entry: LogEntry): void; + getLogEntries(): LogEntry[]; + filterBySection(section: string): LogEntry[]; + header({ command, emoji, level }: { + command: string; + emoji?: string; + level?: LogLevel; + }): LogEntry; + finish({ showDuration, level }?: { + showDuration?: boolean; + level?: LogLevel; + }): LogEntry; + stop(): void; +} +export declare function getLogger(): Logger; +//# sourceMappingURL=logger.d.ts.map \ No newline at end of file diff --git a/garden-service/build/logger/logger.js b/garden-service/build/logger/logger.js new file mode 100644 index 00000000000..1aa87a0c24f --- /dev/null +++ b/garden-service/build/logger/logger.js @@ -0,0 +1,118 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const nodeEmoji = require("node-emoji"); +const chalk_1 = require("chalk"); +const log_node_1 = require("./log-node"); +const log_entry_1 = require("./log-entry"); +const util_1 = require("./util"); +const exceptions_1 = require("../exceptions"); +const log_node_2 = require("./log-node"); +const fancy_terminal_writer_1 = require("./writers/fancy-terminal-writer"); +const basic_terminal_writer_1 = require("./writers/basic-terminal-writer"); +const renderers_1 = require("./renderers"); +var LoggerType; +(function (LoggerType) { + LoggerType["quiet"] = "quiet"; + LoggerType["basic"] = "basic"; + LoggerType["fancy"] = "fancy"; +})(LoggerType = exports.LoggerType || (exports.LoggerType = {})); +function getCommonConfig(loggerType) { + const configs = { + [LoggerType.fancy]: { + level: log_node_2.LogLevel.info, + writers: [new fancy_terminal_writer_1.FancyTerminalWriter()], + }, + [LoggerType.basic]: { + level: log_node_2.LogLevel.info, + writers: [new basic_terminal_writer_1.BasicTerminalWriter()], + }, + [LoggerType.quiet]: { + level: log_node_2.LogLevel.info, + }, + }; + return configs[loggerType]; +} +exports.getCommonConfig = getCommonConfig; +class Logger extends log_node_1.RootLogNode { + static getInstance() { + if (!Logger.instance) { + throw new exceptions_1.InternalError("Logger not initialized", {}); + } + return Logger.instance; + } + static initialize(config) { + if (Logger.instance) { + throw new exceptions_1.InternalError("Logger already initialized", {}); + } + let instance; + // If GARDEN_LOGGER_TYPE env variable is set it takes precedence over the config param + if (process.env.GARDEN_LOGGER_TYPE) { + const loggerType = LoggerType[process.env.GARDEN_LOGGER_TYPE]; + if (!loggerType) { + throw new exceptions_1.ParameterError(`Invalid logger type specified: ${process.env.GARDEN_LOGGER_TYPE}`, { + loggerType: process.env.GARDEN_LOGGER_TYPE, + availableTypes: Object.keys(LoggerType), + }); + } + instance = new Logger(getCommonConfig(loggerType)); + instance.debug(`Setting logger type to ${loggerType} (from GARDEN_LOGGER_TYPE)`); + } + else { + instance = new Logger(config); + } + Logger.instance = instance; + return instance; + } + constructor(config) { + super(config.level); + this.writers = config.writers || []; + } + createNode(level, _parent, opts) { + return new log_entry_1.LogEntry({ level, parent: this, opts: log_entry_1.resolveParam(opts) }); + } + onGraphChange(entry) { + this.writers.forEach(writer => writer.onGraphChange(entry, this)); + } + getLogEntries() { + return util_1.getChildEntries(this).filter(entry => !entry.fromStdStream()); + } + filterBySection(section) { + return util_1.getChildEntries(this).filter(entry => entry.opts.section === section); + } + header({ command, emoji, level = log_node_2.LogLevel.info }) { + const msg = renderers_1.combine([ + [chalk_1.default.bold.magenta(command)], + [emoji ? " " + nodeEmoji.get(emoji) : ""], + ["\n"], + ]); + const lvlStr = log_node_2.LogLevel[level]; + return this[lvlStr](msg); + } + finish({ showDuration = true, level = log_node_2.LogLevel.info } = {}) { + const msg = renderers_1.combine([ + [`\n${nodeEmoji.get("sparkles")} Finished`], + [showDuration ? ` in ${chalk_1.default.bold(this.getDuration() + "s")}` : "!"], + ["\n"], + ]); + const lvlStr = log_node_2.LogLevel[level]; + return this[lvlStr](msg); + } + stop() { + this.getLogEntries().forEach(e => e.stop()); + this.writers.forEach(writer => writer.stop()); + } +} +exports.Logger = Logger; +function getLogger() { + return Logger.getInstance(); +} +exports.getLogger = getLogger; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["logger/logger.ts"],"names":[],"mappings":"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","file":"logger/logger.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as nodeEmoji from \"node-emoji\"\nimport chalk from \"chalk\"\n\nimport { RootLogNode, LogNode } from \"./log-node\"\nimport { LogEntry, CreateOpts, resolveParam } from \"./log-entry\"\nimport { getChildEntries } from \"./util\"\nimport { Writer } from \"./writers/base\"\nimport { InternalError, ParameterError } from \"../exceptions\"\nimport { LogLevel } from \"./log-node\"\nimport { FancyTerminalWriter } from \"./writers/fancy-terminal-writer\"\nimport { BasicTerminalWriter } from \"./writers/basic-terminal-writer\"\nimport { combine } from \"./renderers\"\n\nexport enum LoggerType {\n  quiet = \"quiet\",\n  basic = \"basic\",\n  fancy = \"fancy\",\n}\n\nexport function getCommonConfig(loggerType: LoggerType): LoggerConfig {\n  const configs: { [key in LoggerType]: LoggerConfig } = {\n    [LoggerType.fancy]: {\n      level: LogLevel.info,\n      writers: [new FancyTerminalWriter()],\n    },\n    [LoggerType.basic]: {\n      level: LogLevel.info,\n      writers: [new BasicTerminalWriter()],\n    },\n    [LoggerType.quiet]: {\n      level: LogLevel.info,\n    },\n  }\n  return configs[loggerType]\n}\n\nexport interface LoggerConfig {\n  level: LogLevel\n  writers?: Writer[]\n}\n\nexport class Logger extends RootLogNode<LogEntry> {\n  public writers: Writer[]\n\n  private static instance: Logger\n\n  static getInstance() {\n    if (!Logger.instance) {\n      throw new InternalError(\"Logger not initialized\", {})\n    }\n    return Logger.instance\n  }\n\n  static initialize(config: LoggerConfig) {\n    if (Logger.instance) {\n      throw new InternalError(\"Logger already initialized\", {})\n    }\n\n    let instance\n\n    // If GARDEN_LOGGER_TYPE env variable is set it takes precedence over the config param\n    if (process.env.GARDEN_LOGGER_TYPE) {\n      const loggerType = LoggerType[process.env.GARDEN_LOGGER_TYPE]\n\n      if (!loggerType) {\n        throw new ParameterError(`Invalid logger type specified: ${process.env.GARDEN_LOGGER_TYPE}`, {\n          loggerType: process.env.GARDEN_LOGGER_TYPE,\n          availableTypes: Object.keys(LoggerType),\n        })\n      }\n\n      instance = new Logger(getCommonConfig(loggerType))\n      instance.debug(`Setting logger type to ${loggerType} (from GARDEN_LOGGER_TYPE)`)\n    } else {\n      instance = new Logger(config)\n    }\n\n    Logger.instance = instance\n    return instance\n  }\n\n  private constructor(config: LoggerConfig) {\n    super(config.level)\n    this.writers = config.writers || []\n  }\n\n  createNode(level: LogLevel, _parent: LogNode, opts: CreateOpts) {\n    return new LogEntry({ level, parent: this, opts: resolveParam(opts) })\n  }\n\n  onGraphChange(entry: LogEntry) {\n    this.writers.forEach(writer => writer.onGraphChange(entry, this))\n  }\n\n  getLogEntries(): LogEntry[] {\n    return getChildEntries(this).filter(entry => !entry.fromStdStream())\n  }\n\n  filterBySection(section: string): LogEntry[] {\n    return getChildEntries(this).filter(entry => entry.opts.section === section)\n  }\n\n  header(\n    { command, emoji, level = LogLevel.info }: { command: string, emoji?: string, level?: LogLevel },\n  ): LogEntry {\n    const msg = combine([\n      [chalk.bold.magenta(command)],\n      [emoji ? \" \" + nodeEmoji.get(emoji) : \"\"],\n      [\"\\n\"],\n    ])\n    const lvlStr = LogLevel[level]\n    return this[lvlStr](msg)\n  }\n\n  finish(\n    { showDuration = true, level = LogLevel.info }: { showDuration?: boolean, level?: LogLevel } = {},\n  ): LogEntry {\n    const msg = combine([\n      [`\\n${nodeEmoji.get(\"sparkles\")}  Finished`],\n      [showDuration ? ` in ${chalk.bold(this.getDuration() + \"s\")}` : \"!\"],\n      [\"\\n\"],\n    ])\n    const lvlStr = LogLevel[level]\n    return this[lvlStr](msg)\n  }\n\n  stop(): void {\n    this.getLogEntries().forEach(e => e.stop())\n    this.writers.forEach(writer => writer.stop())\n  }\n\n}\n\nexport function getLogger() {\n  return Logger.getInstance()\n}\n"]} diff --git a/garden-service/build/logger/renderers.d.ts b/garden-service/build/logger/renderers.d.ts new file mode 100644 index 00000000000..cbed51fabec --- /dev/null +++ b/garden-service/build/logger/renderers.d.ts @@ -0,0 +1,19 @@ +import { LogEntry } from "./log-entry"; +export declare type ToRender = string | ((...args: any[]) => string); +export declare type Renderer = [ToRender, any[]] | ToRender[]; +export declare type Renderers = Renderer[]; +export declare const msgStyle: (s: string) => string; +export declare const errorStyle: import("chalk").Chalk & { + supportsColor: import("chalk").ColorSupport; +}; +export declare function combine(renderers: Renderers): string; +/*** RENDERERS ***/ +export declare function leftPad(entry: LogEntry): string; +export declare function renderEmoji(entry: LogEntry): string; +export declare function renderError(entry: LogEntry): string | string[]; +export declare function renderSymbol(entry: LogEntry): string; +export declare function renderMsg(entry: LogEntry): string; +export declare function renderSection(entry: LogEntry): string; +export declare function renderDuration(entry: LogEntry): string; +export declare function formatForTerminal(entry: LogEntry): string; +//# sourceMappingURL=renderers.d.ts.map \ No newline at end of file diff --git a/garden-service/build/logger/renderers.js b/garden-service/build/logger/renderers.js new file mode 100644 index 00000000000..cb1ab102cfc --- /dev/null +++ b/garden-service/build/logger/renderers.js @@ -0,0 +1,125 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const logSymbols = require("log-symbols"); +const nodeEmoji = require("node-emoji"); +const yaml = require("js-yaml"); +const chalk_1 = require("chalk"); +const lodash_1 = require("lodash"); +const cliTruncate = require("cli-truncate"); +const stringWidth = require("string-width"); +const hasAnsi = require("has-ansi"); +/*** STYLE HELPERS ***/ +const SECTION_PREFIX_WIDTH = 25; +const cliPadEnd = (s, width) => { + const diff = width - stringWidth(s); + return diff <= 0 ? s : s + lodash_1.repeat(" ", diff); +}; +const truncateSection = (s) => cliTruncate(s, SECTION_PREFIX_WIDTH); +const sectionStyle = (s) => chalk_1.default.cyan.italic(cliPadEnd(truncateSection(s), SECTION_PREFIX_WIDTH)); +exports.msgStyle = (s) => hasAnsi(s) ? s : chalk_1.default.gray(s); +exports.errorStyle = chalk_1.default.red; +/*** RENDER HELPERS ***/ +function insertVal(out, idx, toRender, renderArgs) { + out[idx] = typeof toRender === "string" ? toRender : toRender(...renderArgs); + return out; +} +// Creates a chain of renderers that each receives the updated output array along with the provided parameters +function applyRenderers(renderers) { + const curried = renderers.map(([toRender, renderArgs], idx) => { + const args = [idx, toRender, renderArgs]; + // FIXME Currying like this throws "Expected 0-4 arguments, but got 0 or more" + return lodash_1.curryRight(insertVal)(...args); + }); + return lodash_1.flow(curried); +} +function combine(renderers) { + const initOutput = []; + return applyRenderers(renderers)(initOutput).join(""); +} +exports.combine = combine; +/*** RENDERERS ***/ +function leftPad(entry) { + return lodash_1.padStart("", (entry.opts.indentationLevel || 0) * 3); +} +exports.leftPad = leftPad; +function renderEmoji(entry) { + const { emoji } = entry.opts; + if (emoji && nodeEmoji.hasEmoji(emoji)) { + return `${nodeEmoji.get(emoji)} `; + } + return ""; +} +exports.renderEmoji = renderEmoji; +function renderError(entry) { + const { msg, error } = entry.opts; + if (error) { + const { detail, message, stack } = error; + let out = stack || message; + if (!lodash_1.isEmpty(detail)) { + const kebabCasedDetail = lodash_1.reduce(detail, (acc, val, key) => { + acc[lodash_1.kebabCase(key)] = val; + return acc; + }, {}); + const yamlDetail = yaml.safeDump(kebabCasedDetail, { noRefs: true, skipInvalid: true }); + out += `\nError Details:\n${yamlDetail}`; + } + return out; + } + return msg || ""; +} +exports.renderError = renderError; +function renderSymbol(entry) { + const { symbol } = entry.opts; + if (symbol === "empty") { + return " "; + } + return symbol ? `${logSymbols[symbol]} ` : ""; +} +exports.renderSymbol = renderSymbol; +function renderMsg(entry) { + const { fromStdStream, msg, status } = entry.opts; + if (fromStdStream) { + return lodash_1.isArray(msg) ? msg.join(" ") : msg || ""; + } + const styleFn = status === "error" ? exports.errorStyle : exports.msgStyle; + if (lodash_1.isArray(msg)) { + // We apply the style function to each item (as opposed to the entire string) in case some + // part of the message already has a style + return msg.map(str => styleFn(str)).join(styleFn(" → ")); + } + return msg ? styleFn(msg) : ""; +} +exports.renderMsg = renderMsg; +function renderSection(entry) { + const { section } = entry.opts; + return section ? `${sectionStyle(section)} → ` : ""; +} +exports.renderSection = renderSection; +function renderDuration(entry) { + const { showDuration = false } = entry.opts; + return showDuration + ? exports.msgStyle(` (finished in ${entry.getDuration()}s)`) + : ""; +} +exports.renderDuration = renderDuration; +function formatForTerminal(entry) { + return combine([ + [leftPad, [entry]], + [renderSymbol, [entry]], + [renderSection, [entry]], + [renderEmoji, [entry]], + [renderMsg, [entry]], + [renderDuration, [entry]], + ["\n"], + ]); +} +exports.formatForTerminal = formatForTerminal; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["logger/renderers.ts"],"names":[],"mappings":"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","file":"logger/renderers.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as logSymbols from \"log-symbols\"\nimport * as nodeEmoji from \"node-emoji\"\nimport * as yaml from \"js-yaml\"\nimport chalk from \"chalk\"\nimport {\n  curryRight,\n  flow,\n  isArray,\n  isEmpty,\n  padStart,\n  reduce,\n  kebabCase,\n  repeat,\n} from \"lodash\"\nimport cliTruncate = require(\"cli-truncate\")\nimport stringWidth = require(\"string-width\")\nimport hasAnsi = require(\"has-ansi\")\n\nimport { LogEntry } from \"./log-entry\"\n\nexport type ToRender = string | ((...args: any[]) => string)\nexport type Renderer = [ToRender, any[]] | ToRender[]\nexport type Renderers = Renderer[]\n\n/*** STYLE HELPERS ***/\n\nconst SECTION_PREFIX_WIDTH = 25\nconst cliPadEnd = (s: string, width: number): string => {\n  const diff = width - stringWidth(s)\n  return diff <= 0 ? s : s + repeat(\" \", diff)\n}\nconst truncateSection = (s: string) => cliTruncate(s, SECTION_PREFIX_WIDTH)\nconst sectionStyle = (s: string) => chalk.cyan.italic(cliPadEnd(truncateSection(s), SECTION_PREFIX_WIDTH))\nexport const msgStyle = (s: string) => hasAnsi(s) ? s : chalk.gray(s)\nexport const errorStyle = chalk.red\n\n/*** RENDER HELPERS ***/\nfunction insertVal(out: string[], idx: number, toRender: Function | string, renderArgs: any[]): string[] {\n  out[idx] = typeof toRender === \"string\" ? toRender : toRender(...renderArgs)\n  return out\n}\n\n// Creates a chain of renderers that each receives the updated output array along with the provided parameters\nfunction applyRenderers(renderers: Renderers): Function {\n  const curried = renderers.map(([toRender, renderArgs]: Renderer, idx: number) => {\n    const args = [idx, toRender, renderArgs]\n    // FIXME Currying like this throws \"Expected 0-4 arguments, but got 0 or more\"\n    return (<any>curryRight)(insertVal)(...args)\n  })\n  return flow(curried)\n}\n\nexport function combine(renderers: Renderers): string {\n  const initOutput = []\n  return applyRenderers(renderers)(initOutput).join(\"\")\n}\n\n/*** RENDERERS ***/\nexport function leftPad(entry: LogEntry): string {\n  return padStart(\"\", (entry.opts.indentationLevel || 0) * 3)\n}\n\nexport function renderEmoji(entry: LogEntry): string {\n  const { emoji } = entry.opts\n  if (emoji && nodeEmoji.hasEmoji(emoji)) {\n    return `${nodeEmoji.get(emoji)}  `\n  }\n  return \"\"\n}\n\nexport function renderError(entry: LogEntry) {\n  const { msg, error } = entry.opts\n  if (error) {\n    const { detail, message, stack } = error\n    let out = stack || message\n    if (!isEmpty(detail)) {\n      const kebabCasedDetail = reduce(detail, (acc, val, key) => {\n        acc[kebabCase(key)] = val\n        return acc\n      }, {})\n      const yamlDetail = yaml.safeDump(kebabCasedDetail, { noRefs: true, skipInvalid: true })\n      out += `\\nError Details:\\n${yamlDetail}`\n    }\n    return out\n  }\n  return msg || \"\"\n}\n\nexport function renderSymbol(entry: LogEntry): string {\n  const { symbol } = entry.opts\n  if (symbol === \"empty\") {\n    return \" \"\n  }\n  return symbol ? `${logSymbols[symbol]} ` : \"\"\n}\n\nexport function renderMsg(entry: LogEntry): string {\n  const { fromStdStream, msg, status } = entry.opts\n\n  if (fromStdStream) {\n    return isArray(msg) ? msg.join(\" \") : msg || \"\"\n  }\n\n  const styleFn = status === \"error\" ? errorStyle : msgStyle\n  if (isArray(msg)) {\n    // We apply the style function to each item (as opposed to the entire string) in case some\n    // part of the message already has a style\n    return msg.map(str => styleFn(str)).join(styleFn(\" → \"))\n  }\n  return msg ? styleFn(msg) : \"\"\n}\n\nexport function renderSection(entry: LogEntry): string {\n  const { section } = entry.opts\n  return section ? `${sectionStyle(section)} → ` : \"\"\n}\n\nexport function renderDuration(entry: LogEntry): string {\n  const { showDuration = false } = entry.opts\n  return showDuration\n    ? msgStyle(` (finished in ${entry.getDuration()}s)`)\n    : \"\"\n}\n\nexport function formatForTerminal(entry: LogEntry): string {\n  return combine([\n    [leftPad, [entry]],\n    [renderSymbol, [entry]],\n    [renderSection, [entry]],\n    [renderEmoji, [entry]],\n    [renderMsg, [entry]],\n    [renderDuration, [entry]],\n    [\"\\n\"],\n  ])\n}\n"]} diff --git a/garden-service/build/logger/util.d.ts b/garden-service/build/logger/util.d.ts new file mode 100644 index 00000000000..6747a9c741c --- /dev/null +++ b/garden-service/build/logger/util.d.ts @@ -0,0 +1,25 @@ +/// +import { LogNode, LogLevel } from "./log-node"; +import { LogEntry, CreateOpts } from "./log-entry"; +export interface Node { + children: any[]; +} +export declare type LogOptsResolvers = { + [K in keyof CreateOpts]?: Function; +}; +export declare type ProcessNode = (node: T) => boolean; +export declare function getChildNodes(node: T | U): U[]; +export declare function getChildEntries(node: LogNode): LogEntry[]; +export declare function findLogNode(node: LogNode, predicate: ProcessNode>): T | void; +/** + * Intercepts the write method of a WriteableStream and calls the provided callback on the + * string to write (or optionally applies the string to the write method) + * Returns a function which sets the write back to default. + * + * Used e.g. by FancyLogger so that writes from other sources can be intercepted + * and pushed to the log stack. + */ +export declare function interceptStream(stream: NodeJS.WriteStream, callback: Function): () => void; +export declare function getTerminalWidth(stream?: NodeJS.WriteStream): number; +export declare function validate(level: LogLevel, entry: LogEntry): boolean; +//# sourceMappingURL=util.d.ts.map \ No newline at end of file diff --git a/garden-service/build/logger/util.js b/garden-service/build/logger/util.js new file mode 100644 index 00000000000..f70737ce859 --- /dev/null +++ b/garden-service/build/logger/util.js @@ -0,0 +1,87 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +function traverseChildren(node, cb) { + const children = node.children; + for (let idx = 0; idx < children.length; idx++) { + const proceed = cb(children[idx]); + if (!proceed) { + return; + } + traverseChildren(children[idx], cb); + } +} +// Parent (T|U) can have different type then child (U) +function getChildNodes(node) { + let childNodes = []; + traverseChildren(node, child => { + childNodes.push(child); + return true; + }); + return childNodes; +} +exports.getChildNodes = getChildNodes; +function getChildEntries(node) { + return getChildNodes(node); +} +exports.getChildEntries = getChildEntries; +function findLogNode(node, predicate) { + let found; + traverseChildren(node, entry => { + if (predicate(entry)) { + found = entry; + return false; + } + return true; + }); + return found; +} +exports.findLogNode = findLogNode; +/** + * Intercepts the write method of a WriteableStream and calls the provided callback on the + * string to write (or optionally applies the string to the write method) + * Returns a function which sets the write back to default. + * + * Used e.g. by FancyLogger so that writes from other sources can be intercepted + * and pushed to the log stack. + */ +function interceptStream(stream, callback) { + const prevWrite = stream.write; + stream.write = (write => (string, encoding, cb, extraParam) => { + if (extraParam && extraParam.noIntercept) { + const args = [string, encoding, cb]; + return write.apply(stream, args); + } + callback(string); + return true; + })(stream.write); + const restore = () => { + stream.write = prevWrite; + }; + return restore; +} +exports.interceptStream = interceptStream; +function getTerminalWidth(stream = process.stdout) { + const columns = (stream || {}).columns; + if (!columns) { + return 80; + } + // Windows appears to wrap a character early + if (process.platform === "win32") { + return columns - 1; + } + return columns; +} +exports.getTerminalWidth = getTerminalWidth; +function validate(level, entry) { + return level >= entry.level && entry.opts.msg !== undefined; +} +exports.validate = validate; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxvZ2dlci91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7O0FBYUgsU0FBUyxnQkFBZ0IsQ0FBaUMsSUFBVyxFQUFFLEVBQWtCO0lBQ3ZGLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUE7SUFDOUIsS0FBSyxJQUFJLEdBQUcsR0FBRyxDQUFDLEVBQUUsR0FBRyxHQUFHLFFBQVEsQ0FBQyxNQUFNLEVBQUUsR0FBRyxFQUFFLEVBQUU7UUFDOUMsTUFBTSxPQUFPLEdBQUcsRUFBRSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFBO1FBQ2pDLElBQUksQ0FBQyxPQUFPLEVBQUU7WUFDWixPQUFNO1NBQ1A7UUFDRCxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUE7S0FDcEM7QUFDSCxDQUFDO0FBRUQsc0RBQXNEO0FBQ3RELFNBQWdCLGFBQWEsQ0FBaUMsSUFBVztJQUN2RSxJQUFJLFVBQVUsR0FBUSxFQUFFLENBQUE7SUFDeEIsZ0JBQWdCLENBQU8sSUFBSSxFQUFFLEtBQUssQ0FBQyxFQUFFO1FBQ25DLFVBQVUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7UUFDdEIsT0FBTyxJQUFJLENBQUE7SUFDYixDQUFDLENBQUMsQ0FBQTtJQUNGLE9BQU8sVUFBVSxDQUFBO0FBQ25CLENBQUM7QUFQRCxzQ0FPQztBQUVELFNBQWdCLGVBQWUsQ0FBQyxJQUFhO0lBQzNDLE9BQU8sYUFBYSxDQUFvQixJQUFJLENBQUMsQ0FBQTtBQUMvQyxDQUFDO0FBRkQsMENBRUM7QUFFRCxTQUFnQixXQUFXLENBQUksSUFBZ0IsRUFBRSxTQUFrQztJQUNqRixJQUFJLEtBQUssQ0FBQTtJQUNULGdCQUFnQixDQUF5QixJQUFJLEVBQUUsS0FBSyxDQUFDLEVBQUU7UUFDckQsSUFBSSxTQUFTLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDcEIsS0FBSyxHQUFHLEtBQUssQ0FBQTtZQUNiLE9BQU8sS0FBSyxDQUFBO1NBQ2I7UUFDRCxPQUFPLElBQUksQ0FBQTtJQUNiLENBQUMsQ0FBQyxDQUFBO0lBQ0YsT0FBTyxLQUFLLENBQUE7QUFDZCxDQUFDO0FBVkQsa0NBVUM7QUFNRDs7Ozs7OztHQU9HO0FBQ0gsU0FBZ0IsZUFBZSxDQUFDLE1BQTBCLEVBQUUsUUFBa0I7SUFDNUUsTUFBTSxTQUFTLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQTtJQUU5QixNQUFNLENBQUMsS0FBSyxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FDdEIsQ0FDRSxNQUFjLEVBQ2QsUUFBaUIsRUFDakIsRUFBYSxFQUNiLFVBQWtDLEVBQ3pCLEVBQUU7UUFDWCxJQUFJLFVBQVUsSUFBSSxVQUFVLENBQUMsV0FBVyxFQUFFO1lBQ3hDLE1BQU0sSUFBSSxHQUFHLENBQUMsTUFBTSxFQUFFLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQTtZQUNuQyxPQUFPLEtBQUssQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFBO1NBQ2pDO1FBQ0QsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFBO1FBQ2hCLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBUSxDQUFBO0lBRXpCLE1BQU0sT0FBTyxHQUFHLEdBQUcsRUFBRTtRQUNuQixNQUFNLENBQUMsS0FBSyxHQUFHLFNBQVMsQ0FBQTtJQUMxQixDQUFDLENBQUE7SUFFRCxPQUFPLE9BQU8sQ0FBQTtBQUNoQixDQUFDO0FBdkJELDBDQXVCQztBQUVELFNBQWdCLGdCQUFnQixDQUFDLFNBQTZCLE9BQU8sQ0FBQyxNQUFNO0lBQzFFLE1BQU0sT0FBTyxHQUFHLENBQUMsTUFBTSxJQUFJLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQTtJQUV0QyxJQUFJLENBQUMsT0FBTyxFQUFFO1FBQ1osT0FBTyxFQUFFLENBQUE7S0FDVjtJQUVELDRDQUE0QztJQUM1QyxJQUFJLE9BQU8sQ0FBQyxRQUFRLEtBQUssT0FBTyxFQUFFO1FBQ2hDLE9BQU8sT0FBTyxHQUFHLENBQUMsQ0FBQTtLQUNuQjtJQUVELE9BQU8sT0FBTyxDQUFBO0FBQ2hCLENBQUM7QUFiRCw0Q0FhQztBQUVELFNBQWdCLFFBQVEsQ0FBQyxLQUFlLEVBQUUsS0FBZTtJQUN2RCxPQUFPLEtBQUssSUFBSSxLQUFLLENBQUMsS0FBSyxJQUFJLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxLQUFLLFNBQVMsQ0FBQTtBQUM3RCxDQUFDO0FBRkQsNEJBRUMiLCJmaWxlIjoibG9nZ2VyL3V0aWwuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChDKSAyMDE4IEdhcmRlbiBUZWNobm9sb2dpZXMsIEluYy4gPGluZm9AZ2FyZGVuLmlvPlxuICpcbiAqIFRoaXMgU291cmNlIENvZGUgRm9ybSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGUgTW96aWxsYSBQdWJsaWNcbiAqIExpY2Vuc2UsIHYuIDIuMC4gSWYgYSBjb3B5IG9mIHRoZSBNUEwgd2FzIG5vdCBkaXN0cmlidXRlZCB3aXRoIHRoaXNcbiAqIGZpbGUsIFlvdSBjYW4gb2J0YWluIG9uZSBhdCBodHRwOi8vbW96aWxsYS5vcmcvTVBMLzIuMC8uXG4gKi9cblxuaW1wb3J0IHsgTG9nTm9kZSwgTG9nTGV2ZWwgfSBmcm9tIFwiLi9sb2ctbm9kZVwiXG5pbXBvcnQgeyBMb2dFbnRyeSwgQ3JlYXRlT3B0cyB9IGZyb20gXCIuL2xvZy1lbnRyeVwiXG5cbmV4cG9ydCBpbnRlcmZhY2UgTm9kZSB7XG4gIGNoaWxkcmVuOiBhbnlbXVxufVxuXG5leHBvcnQgdHlwZSBMb2dPcHRzUmVzb2x2ZXJzID0geyBbSyBpbiBrZXlvZiBDcmVhdGVPcHRzXT86IEZ1bmN0aW9uIH1cblxuZXhwb3J0IHR5cGUgUHJvY2Vzc05vZGU8VCBleHRlbmRzIE5vZGUgPSBOb2RlPiA9IChub2RlOiBUKSA9PiBib29sZWFuXG5cbmZ1bmN0aW9uIHRyYXZlcnNlQ2hpbGRyZW48VCBleHRlbmRzIE5vZGUsIFUgZXh0ZW5kcyBOb2RlPihub2RlOiBUIHwgVSwgY2I6IFByb2Nlc3NOb2RlPFU+KSB7XG4gIGNvbnN0IGNoaWxkcmVuID0gbm9kZS5jaGlsZHJlblxuICBmb3IgKGxldCBpZHggPSAwOyBpZHggPCBjaGlsZHJlbi5sZW5ndGg7IGlkeCsrKSB7XG4gICAgY29uc3QgcHJvY2VlZCA9IGNiKGNoaWxkcmVuW2lkeF0pXG4gICAgaWYgKCFwcm9jZWVkKSB7XG4gICAgICByZXR1cm5cbiAgICB9XG4gICAgdHJhdmVyc2VDaGlsZHJlbihjaGlsZHJlbltpZHhdLCBjYilcbiAgfVxufVxuXG4vLyBQYXJlbnQgKFR8VSkgY2FuIGhhdmUgZGlmZmVyZW50IHR5cGUgdGhlbiBjaGlsZCAoVSlcbmV4cG9ydCBmdW5jdGlvbiBnZXRDaGlsZE5vZGVzPFQgZXh0ZW5kcyBOb2RlLCBVIGV4dGVuZHMgTm9kZT4obm9kZTogVCB8IFUpOiBVW10ge1xuICBsZXQgY2hpbGROb2RlczogVVtdID0gW11cbiAgdHJhdmVyc2VDaGlsZHJlbjxULCBVPihub2RlLCBjaGlsZCA9PiB7XG4gICAgY2hpbGROb2Rlcy5wdXNoKGNoaWxkKVxuICAgIHJldHVybiB0cnVlXG4gIH0pXG4gIHJldHVybiBjaGlsZE5vZGVzXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRDaGlsZEVudHJpZXMobm9kZTogTG9nTm9kZSk6IExvZ0VudHJ5W10ge1xuICByZXR1cm4gZ2V0Q2hpbGROb2RlczxMb2dOb2RlLCBMb2dFbnRyeT4obm9kZSlcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGZpbmRMb2dOb2RlPFQ+KG5vZGU6IExvZ05vZGU8VD4sIHByZWRpY2F0ZTogUHJvY2Vzc05vZGU8TG9nTm9kZTxUPj4pOiBUIHwgdm9pZCB7XG4gIGxldCBmb3VuZFxuICB0cmF2ZXJzZUNoaWxkcmVuPExvZ05vZGU8VD4sIExvZ05vZGU8VD4+KG5vZGUsIGVudHJ5ID0+IHtcbiAgICBpZiAocHJlZGljYXRlKGVudHJ5KSkge1xuICAgICAgZm91bmQgPSBlbnRyeVxuICAgICAgcmV0dXJuIGZhbHNlXG4gICAgfVxuICAgIHJldHVybiB0cnVlXG4gIH0pXG4gIHJldHVybiBmb3VuZFxufVxuXG5pbnRlcmZhY2UgU3RyZWFtV3JpdGVFeHRyYVBhcmFtIHtcbiAgbm9JbnRlcmNlcHQ/OiBib29sZWFuXG59XG5cbi8qKlxuICogSW50ZXJjZXB0cyB0aGUgd3JpdGUgbWV0aG9kIG9mIGEgV3JpdGVhYmxlU3RyZWFtIGFuZCBjYWxscyB0aGUgcHJvdmlkZWQgY2FsbGJhY2sgb24gdGhlXG4gKiBzdHJpbmcgdG8gd3JpdGUgKG9yIG9wdGlvbmFsbHkgYXBwbGllcyB0aGUgc3RyaW5nIHRvIHRoZSB3cml0ZSBtZXRob2QpXG4gKiBSZXR1cm5zIGEgZnVuY3Rpb24gd2hpY2ggc2V0cyB0aGUgd3JpdGUgYmFjayB0byBkZWZhdWx0LlxuICpcbiAqIFVzZWQgZS5nLiBieSBGYW5jeUxvZ2dlciBzbyB0aGF0IHdyaXRlcyBmcm9tIG90aGVyIHNvdXJjZXMgY2FuIGJlIGludGVyY2VwdGVkXG4gKiBhbmQgcHVzaGVkIHRvIHRoZSBsb2cgc3RhY2suXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpbnRlcmNlcHRTdHJlYW0oc3RyZWFtOiBOb2RlSlMuV3JpdGVTdHJlYW0sIGNhbGxiYWNrOiBGdW5jdGlvbikge1xuICBjb25zdCBwcmV2V3JpdGUgPSBzdHJlYW0ud3JpdGVcblxuICBzdHJlYW0ud3JpdGUgPSAod3JpdGUgPT5cbiAgICAoXG4gICAgICBzdHJpbmc6IHN0cmluZyxcbiAgICAgIGVuY29kaW5nPzogc3RyaW5nLFxuICAgICAgY2I/OiBGdW5jdGlvbixcbiAgICAgIGV4dHJhUGFyYW0/OiBTdHJlYW1Xcml0ZUV4dHJhUGFyYW0sXG4gICAgKTogYm9vbGVhbiA9PiB7XG4gICAgICBpZiAoZXh0cmFQYXJhbSAmJiBleHRyYVBhcmFtLm5vSW50ZXJjZXB0KSB7XG4gICAgICAgIGNvbnN0IGFyZ3MgPSBbc3RyaW5nLCBlbmNvZGluZywgY2JdXG4gICAgICAgIHJldHVybiB3cml0ZS5hcHBseShzdHJlYW0sIGFyZ3MpXG4gICAgICB9XG4gICAgICBjYWxsYmFjayhzdHJpbmcpXG4gICAgICByZXR1cm4gdHJ1ZVxuICAgIH0pKHN0cmVhbS53cml0ZSkgYXMgYW55XG5cbiAgY29uc3QgcmVzdG9yZSA9ICgpID0+IHtcbiAgICBzdHJlYW0ud3JpdGUgPSBwcmV2V3JpdGVcbiAgfVxuXG4gIHJldHVybiByZXN0b3JlXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRUZXJtaW5hbFdpZHRoKHN0cmVhbTogTm9kZUpTLldyaXRlU3RyZWFtID0gcHJvY2Vzcy5zdGRvdXQpIHtcbiAgY29uc3QgY29sdW1ucyA9IChzdHJlYW0gfHwge30pLmNvbHVtbnNcblxuICBpZiAoIWNvbHVtbnMpIHtcbiAgICByZXR1cm4gODBcbiAgfVxuXG4gIC8vIFdpbmRvd3MgYXBwZWFycyB0byB3cmFwIGEgY2hhcmFjdGVyIGVhcmx5XG4gIGlmIChwcm9jZXNzLnBsYXRmb3JtID09PSBcIndpbjMyXCIpIHtcbiAgICByZXR1cm4gY29sdW1ucyAtIDFcbiAgfVxuXG4gIHJldHVybiBjb2x1bW5zXG59XG5cbmV4cG9ydCBmdW5jdGlvbiB2YWxpZGF0ZShsZXZlbDogTG9nTGV2ZWwsIGVudHJ5OiBMb2dFbnRyeSk6IGJvb2xlYW4ge1xuICByZXR1cm4gbGV2ZWwgPj0gZW50cnkubGV2ZWwgJiYgZW50cnkub3B0cy5tc2cgIT09IHVuZGVmaW5lZFxufVxuIl19 diff --git a/garden-service/build/logger/writers/base.d.ts b/garden-service/build/logger/writers/base.d.ts new file mode 100644 index 00000000000..5e11a42f72e --- /dev/null +++ b/garden-service/build/logger/writers/base.d.ts @@ -0,0 +1,14 @@ +import { LogLevel } from "../log-node"; +import { LogEntry } from "../log-entry"; +import { Logger } from "../logger"; +export interface WriterConfig { + level?: LogLevel; +} +export declare abstract class Writer { + level: LogLevel | undefined; + constructor({ level }?: WriterConfig); + abstract render(...args: any[]): string | string[] | null; + abstract onGraphChange(entry: LogEntry, logger: Logger): void; + abstract stop(): void; +} +//# sourceMappingURL=base.d.ts.map \ No newline at end of file diff --git a/garden-service/build/logger/writers/base.js b/garden-service/build/logger/writers/base.js new file mode 100644 index 00000000000..6a6de548bed --- /dev/null +++ b/garden-service/build/logger/writers/base.js @@ -0,0 +1,17 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +class Writer { + constructor({ level } = {}) { + this.level = level; + } +} +exports.Writer = Writer; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxvZ2dlci93cml0ZXJzL2Jhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7QUFVSCxNQUFzQixNQUFNO0lBRzFCLFlBQVksRUFBRSxLQUFLLEtBQW1CLEVBQUU7UUFDdEMsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUE7SUFDcEIsQ0FBQztDQUtGO0FBVkQsd0JBVUMiLCJmaWxlIjoibG9nZ2VyL3dyaXRlcnMvYmFzZS5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKEMpIDIwMTggR2FyZGVuIFRlY2hub2xvZ2llcywgSW5jLiA8aW5mb0BnYXJkZW4uaW8+XG4gKlxuICogVGhpcyBTb3VyY2UgQ29kZSBGb3JtIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoZSBNb3ppbGxhIFB1YmxpY1xuICogTGljZW5zZSwgdi4gMi4wLiBJZiBhIGNvcHkgb2YgdGhlIE1QTCB3YXMgbm90IGRpc3RyaWJ1dGVkIHdpdGggdGhpc1xuICogZmlsZSwgWW91IGNhbiBvYnRhaW4gb25lIGF0IGh0dHA6Ly9tb3ppbGxhLm9yZy9NUEwvMi4wLy5cbiAqL1xuXG5pbXBvcnQgeyBMb2dMZXZlbCB9IGZyb20gXCIuLi9sb2ctbm9kZVwiXG5pbXBvcnQgeyBMb2dFbnRyeSB9IGZyb20gXCIuLi9sb2ctZW50cnlcIlxuaW1wb3J0IHsgTG9nZ2VyIH0gZnJvbSBcIi4uL2xvZ2dlclwiXG5cbmV4cG9ydCBpbnRlcmZhY2UgV3JpdGVyQ29uZmlnIHtcbiAgbGV2ZWw/OiBMb2dMZXZlbFxufVxuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgV3JpdGVyIHtcbiAgcHVibGljIGxldmVsOiBMb2dMZXZlbCB8IHVuZGVmaW5lZFxuXG4gIGNvbnN0cnVjdG9yKHsgbGV2ZWwgfTogV3JpdGVyQ29uZmlnID0ge30pIHtcbiAgICB0aGlzLmxldmVsID0gbGV2ZWxcbiAgfVxuXG4gIGFic3RyYWN0IHJlbmRlciguLi5hcmdzKTogc3RyaW5nIHwgc3RyaW5nW10gfCBudWxsXG4gIGFic3RyYWN0IG9uR3JhcGhDaGFuZ2UoZW50cnk6IExvZ0VudHJ5LCBsb2dnZXI6IExvZ2dlcik6IHZvaWRcbiAgYWJzdHJhY3Qgc3RvcCgpOiB2b2lkXG59XG4iXX0= diff --git a/garden-service/build/logger/writers/basic-terminal-writer.d.ts b/garden-service/build/logger/writers/basic-terminal-writer.d.ts new file mode 100644 index 00000000000..8d33a43faea --- /dev/null +++ b/garden-service/build/logger/writers/basic-terminal-writer.d.ts @@ -0,0 +1,11 @@ +import { LogLevel } from "../log-node"; +import { LogEntry } from "../log-entry"; +import { Logger } from "../logger"; +import { Writer } from "./base"; +export declare class BasicTerminalWriter extends Writer { + level: LogLevel; + render(entry: LogEntry, logger: Logger): string | null; + onGraphChange(entry: LogEntry, logger: Logger): void; + stop(): void; +} +//# sourceMappingURL=basic-terminal-writer.d.ts.map \ No newline at end of file diff --git a/garden-service/build/logger/writers/basic-terminal-writer.js b/garden-service/build/logger/writers/basic-terminal-writer.js new file mode 100644 index 00000000000..e86c58fc4fc --- /dev/null +++ b/garden-service/build/logger/writers/basic-terminal-writer.js @@ -0,0 +1,31 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const renderers_1 = require("../renderers"); +const util_1 = require("../util"); +const base_1 = require("./base"); +class BasicTerminalWriter extends base_1.Writer { + render(entry, logger) { + const level = this.level || logger.level; + if (util_1.validate(level, entry)) { + return renderers_1.formatForTerminal(entry); + } + return null; + } + onGraphChange(entry, logger) { + const out = this.render(entry, logger); + if (out) { + process.stdout.write(out); + } + } + stop() { } +} +exports.BasicTerminalWriter = BasicTerminalWriter; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/logger/writers/fancy-terminal-writer.d.ts b/garden-service/build/logger/writers/fancy-terminal-writer.d.ts new file mode 100644 index 00000000000..06d18d8730d --- /dev/null +++ b/garden-service/build/logger/writers/fancy-terminal-writer.d.ts @@ -0,0 +1,40 @@ +/// +import { LogEntry } from "../log-entry"; +import { Logger } from "../logger"; +import { LogLevel } from "../log-node"; +import { Writer, WriterConfig } from "./base"; +export declare type Coords = [number, number]; +export interface TerminalEntry { + key: string; + text: string; + lineNumber: number; + spinnerCoords?: Coords; +} +export interface TerminalEntryWithSpinner extends TerminalEntry { + spinnerCoords: Coords; +} +export interface CustomStream extends NodeJS.WriteStream { + cleanUp: Function; +} +export declare class FancyTerminalWriter extends Writer { + private spinners; + private intervalID; + private stream; + private prevOutput; + private lastInterceptAt; + private updatePending; + level: LogLevel; + constructor(config?: WriterConfig); + private initStream; + private spin; + private startLoop; + private stopLoop; + private tickSpinner; + private write; + private handleGraphChange; + toTerminalEntries(logger: Logger): TerminalEntry[]; + render(terminalEntries: TerminalEntry[]): string[]; + onGraphChange(logEntry: LogEntry, logger: Logger): void; + stop(): void; +} +//# sourceMappingURL=fancy-terminal-writer.d.ts.map \ No newline at end of file diff --git a/garden-service/build/logger/writers/fancy-terminal-writer.js b/garden-service/build/logger/writers/fancy-terminal-writer.js new file mode 100644 index 00000000000..739bc6759d1 --- /dev/null +++ b/garden-service/build/logger/writers/fancy-terminal-writer.js @@ -0,0 +1,175 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const ansiEscapes = require("ansi-escapes"); +const cliCursor = require("cli-cursor"); +const elegantSpinner = require("elegant-spinner"); +const wrapAnsi = require("wrap-ansi"); +const chalk_1 = require("chalk"); +const renderers_1 = require("../renderers"); +const util_1 = require("../util"); +const base_1 = require("./base"); +const INTERVAL_MS = 60; +const THROTTLE_MS = 600; +const spinnerStyle = chalk_1.default.cyan; +class FancyTerminalWriter extends base_1.Writer { + constructor(config = {}) { + super(config); + this.intervalID = null; + this.spinners = {}; // Each entry has it's own spinner + this.prevOutput = []; + this.lastInterceptAt = null; + this.updatePending = false; + } + initStream(logger) { + // Create custom stream that calls write method with the 'noIntercept' option. + const stream = Object.assign({}, process.stdout, { write: (str, enc, cb) => process.stdout.write(str, enc, cb, { noIntercept: true }) }); + const onIntercept = msg => logger.info({ msg, fromStdStream: true }); + const restoreStreamFns = [ + util_1.interceptStream(process.stdout, onIntercept), + util_1.interceptStream(process.stderr, onIntercept), + ]; + stream.cleanUp = () => { + cliCursor.show(this.stream); + restoreStreamFns.forEach(restoreStream => restoreStream()); + }; + return stream; + } + spin(entries, totalLines) { + entries.forEach(e => { + let out = ""; + const [x, y] = e.spinnerCoords; + const termX = x === 0 ? x : x + 1; + const termY = -(totalLines - y - 1); + out += ansiEscapes.cursorSavePosition; + out += ansiEscapes.cursorTo(0); // Ensure cursor is to the left + out += ansiEscapes.cursorMove(termX, termY); + out += spinnerStyle(this.tickSpinner(e.key)); + out += ansiEscapes.cursorRestorePosition; + this.stream.write(out); + }); + } + startLoop(entries, totalLines) { + this.stopLoop(); + this.intervalID = setInterval(() => this.spin(entries, totalLines), INTERVAL_MS); + } + stopLoop() { + if (this.intervalID) { + clearInterval(this.intervalID); + this.intervalID = null; + } + } + tickSpinner(key) { + if (!this.spinners[key]) { + this.spinners[key] = elegantSpinner(); + } + return this.spinners[key](); + } + write(output, nextEntry) { + cliCursor.hide(this.stream); + const lineNumber = output.length >= this.prevOutput.length ? nextEntry.lineNumber : 0; + const nLinesToErase = this.prevOutput.length - lineNumber; + this.stream.write(ansiEscapes.eraseLines(nLinesToErase) + output.slice(lineNumber).join("\n")); + } + handleGraphChange(logEntry, logger, didWrite = false) { + this.updatePending = false; + // Suspend processing and write immediately if a lot of data is being intercepted, e.g. when user is typing in input + if (logEntry.fromStdStream() && !didWrite) { + const now = Date.now(); + const throttleProcessing = this.lastInterceptAt && (now - this.lastInterceptAt) < THROTTLE_MS; + this.lastInterceptAt = now; + if (throttleProcessing) { + this.stopLoop(); + this.stream.write(renderers_1.renderMsg(logEntry)); + this.updatePending = true; + // Resume processing if idle and original update is still pending + setTimeout(() => { + if (this.updatePending) { + this.handleGraphChange(logEntry, logger, true); + } + }, THROTTLE_MS); + return; + } + } + const terminalEntries = this.toTerminalEntries(logger); + const nextEntry = terminalEntries.find(e => e.key === logEntry.key); + // Nothing to do, e.g. because entry level is higher than writer level + if (!nextEntry) { + return; + } + const output = this.render(terminalEntries); + if (!didWrite) { + this.write(output, nextEntry); + } + const entriesWithspinner = terminalEntries.filter(e => e.spinnerCoords); + if (entriesWithspinner.length > 0) { + this.startLoop(entriesWithspinner, output.length); + } + else { + this.stopLoop(); + } + this.prevOutput = output; + } + toTerminalEntries(logger) { + const level = this.level || logger.level; + let currentLineNumber = 0; + return util_1.getChildEntries(logger) + .filter(entry => util_1.validate(level, entry)) + .reduce((acc, entry) => { + let spinnerFrame = ""; + let spinnerX; + let spinnerCoords; + if (entry.opts.status === "active") { + spinnerX = renderers_1.leftPad(entry).length; + spinnerFrame = this.tickSpinner(entry.key); + spinnerCoords = [spinnerX, currentLineNumber]; + } + else { + delete this.spinners[entry.key]; + } + const text = [entry] + .map(e => (e.fromStdStream() + ? renderers_1.renderMsg(e) + : renderers_1.formatForTerminal(e))) + .map(str => (spinnerFrame + ? `${str.slice(0, spinnerX)}${spinnerStyle(spinnerFrame)} ${str.slice(spinnerX)}` + : str)) + .map(str => wrapAnsi(str, util_1.getTerminalWidth(this.stream), { + trim: false, + hard: true, + wordWrap: false, + })) + .pop(); + acc.push({ + key: entry.key, + lineNumber: currentLineNumber, + spinnerCoords, + text, + }); + currentLineNumber += text.split("\n").length - 1; + return acc; + }, []); + } + render(terminalEntries) { + return terminalEntries.map(e => e.text).join("").split("\n"); + } + onGraphChange(logEntry, logger) { + if (!this.stream) { + this.stream = this.initStream(logger); + } + this.handleGraphChange(logEntry, logger, false); + } + stop() { + this.stopLoop(); + this.stream && this.stream.cleanUp(); + } +} +exports.FancyTerminalWriter = FancyTerminalWriter; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["logger/writers/fancy-terminal-writer.ts"],"names":[],"mappings":"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","file":"logger/writers/fancy-terminal-writer.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as ansiEscapes from \"ansi-escapes\"\nimport * as cliCursor from \"cli-cursor\"\nimport * as elegantSpinner from \"elegant-spinner\"\nimport * as wrapAnsi from \"wrap-ansi\"\nimport chalk from \"chalk\"\n\nimport {\n  formatForTerminal,\n  leftPad,\n  renderMsg,\n} from \"../renderers\"\nimport { LogEntry } from \"../log-entry\"\nimport { Logger } from \"../logger\"\nimport { LogLevel } from \"../log-node\"\nimport {\n  getChildEntries,\n  getTerminalWidth,\n  interceptStream,\n  validate,\n} from \"../util\"\nimport { Writer, WriterConfig } from \"./base\"\n\nconst INTERVAL_MS = 60\nconst THROTTLE_MS = 600\n\nconst spinnerStyle = chalk.cyan\n\nexport type Coords = [number, number]\n\nexport interface TerminalEntry {\n  key: string\n  text: string\n  lineNumber: number\n  spinnerCoords?: Coords\n}\n\nexport interface TerminalEntryWithSpinner extends TerminalEntry {\n  spinnerCoords: Coords\n}\n\nexport interface CustomStream extends NodeJS.WriteStream {\n  cleanUp: Function\n}\n\nexport class FancyTerminalWriter extends Writer {\n  private spinners: { [key: string]: Function }\n  private intervalID: NodeJS.Timer | null\n  private stream: CustomStream\n  private prevOutput: string[]\n  private lastInterceptAt: number | null\n  private updatePending: boolean\n\n  public level: LogLevel\n\n  constructor(config: WriterConfig = {}) {\n    super(config)\n    this.intervalID = null\n    this.spinners = {} // Each entry has it's own spinner\n    this.prevOutput = []\n    this.lastInterceptAt = null\n    this.updatePending = false\n  }\n\n  private initStream(logger: Logger): CustomStream {\n    // Create custom stream that calls write method with the 'noIntercept' option.\n    const stream = <CustomStream>{\n      ...process.stdout,\n      write: (str, enc, cb) => (<any>process.stdout.write)(str, enc, cb, { noIntercept: true }),\n    }\n\n    const onIntercept = msg => logger.info({ msg, fromStdStream: true })\n\n    const restoreStreamFns = [\n      interceptStream(process.stdout, onIntercept),\n      interceptStream(process.stderr, onIntercept),\n    ]\n\n    stream.cleanUp = () => {\n      cliCursor.show(this.stream)\n      restoreStreamFns.forEach(restoreStream => restoreStream())\n    }\n\n    return stream\n  }\n\n  private spin(entries: TerminalEntryWithSpinner[], totalLines: number): void {\n    entries.forEach(e => {\n      let out = \"\"\n      const [x, y] = e.spinnerCoords\n      const termX = x === 0 ? x : x + 1\n      const termY = -(totalLines - y - 1)\n      out += ansiEscapes.cursorSavePosition\n      out += ansiEscapes.cursorTo(0) // Ensure cursor is to the left\n      out += ansiEscapes.cursorMove(termX, termY)\n      out += spinnerStyle(this.tickSpinner(e.key))\n      out += ansiEscapes.cursorRestorePosition\n      this.stream.write(out)\n    })\n  }\n\n  private startLoop(entries: TerminalEntryWithSpinner[], totalLines: number): void {\n    this.stopLoop()\n    this.intervalID = setInterval(\n      () => this.spin(entries, totalLines),\n      INTERVAL_MS,\n    )\n  }\n\n  private stopLoop(): void {\n    if (this.intervalID) {\n      clearInterval(this.intervalID)\n      this.intervalID = null\n    }\n  }\n\n  private tickSpinner(key: string): string {\n    if (!this.spinners[key]) {\n      this.spinners[key] = elegantSpinner()\n    }\n    return this.spinners[key]()\n  }\n\n  private write(output: string[], nextEntry: TerminalEntry) {\n    cliCursor.hide(this.stream)\n\n    const lineNumber = output.length >= this.prevOutput.length ? nextEntry.lineNumber : 0\n    const nLinesToErase = this.prevOutput.length - lineNumber\n    this.stream.write(\n      ansiEscapes.eraseLines(nLinesToErase) + output.slice(lineNumber).join(\"\\n\"),\n    )\n  }\n\n  private handleGraphChange(logEntry: LogEntry, logger: Logger, didWrite: boolean = false) {\n    this.updatePending = false\n\n    // Suspend processing and write immediately if a lot of data is being intercepted, e.g. when user is typing in input\n    if (logEntry.fromStdStream() && !didWrite) {\n      const now = Date.now()\n      const throttleProcessing = this.lastInterceptAt && (now - this.lastInterceptAt) < THROTTLE_MS\n      this.lastInterceptAt = now\n\n      if (throttleProcessing) {\n        this.stopLoop()\n        this.stream.write(renderMsg(logEntry))\n        this.updatePending = true\n\n        // Resume processing if idle and original update is still pending\n        setTimeout(() => {\n          if (this.updatePending) {\n            this.handleGraphChange(logEntry, logger, true)\n          }\n        }, THROTTLE_MS)\n        return\n      }\n    }\n\n    const terminalEntries = this.toTerminalEntries(logger)\n    const nextEntry = terminalEntries.find(e => e.key === logEntry.key)\n\n    // Nothing to do, e.g. because entry level is higher than writer level\n    if (!nextEntry) {\n      return\n    }\n\n    const output = this.render(terminalEntries)\n    if (!didWrite) {\n      this.write(output, nextEntry)\n    }\n\n    const entriesWithspinner = <TerminalEntryWithSpinner[]>terminalEntries.filter(e => e.spinnerCoords)\n\n    if (entriesWithspinner.length > 0) {\n      this.startLoop(entriesWithspinner, output.length)\n    } else {\n      this.stopLoop()\n    }\n\n    this.prevOutput = output\n  }\n\n  public toTerminalEntries(logger: Logger): TerminalEntry[] {\n    const level = this.level || logger.level\n    let currentLineNumber = 0\n\n    return getChildEntries(logger)\n      .filter(entry => validate(level, entry))\n      .reduce((acc: TerminalEntry[], entry: LogEntry): TerminalEntry[] => {\n        let spinnerFrame = \"\"\n        let spinnerX\n        let spinnerCoords: Coords | undefined\n\n        if (entry.opts.status === \"active\") {\n          spinnerX = leftPad(entry).length\n          spinnerFrame = this.tickSpinner(entry.key)\n          spinnerCoords = [spinnerX, currentLineNumber]\n        } else {\n          delete this.spinners[entry.key]\n        }\n\n        const text = [entry]\n          .map(e => (\n            e.fromStdStream()\n              ? renderMsg(e)\n              : formatForTerminal(e)\n          ))\n          .map(str => (\n            spinnerFrame\n              ? `${str.slice(0, spinnerX)}${spinnerStyle(spinnerFrame)} ${str.slice(spinnerX)}`\n              : str\n          ))\n          .map(str => wrapAnsi(str, getTerminalWidth(this.stream), {\n            trim: false,\n            hard: true,\n            wordWrap: false,\n          }))\n          .pop()!\n\n        acc.push({\n          key: entry.key,\n          lineNumber: currentLineNumber,\n          spinnerCoords,\n          text,\n        })\n\n        currentLineNumber += text.split(\"\\n\").length - 1\n\n        return acc\n      }, [])\n  }\n\n  public render(terminalEntries: TerminalEntry[]): string[] {\n    return terminalEntries.map(e => e.text).join(\"\").split(\"\\n\")\n  }\n\n  public onGraphChange(logEntry: LogEntry, logger: Logger): void {\n    if (!this.stream) {\n      this.stream = this.initStream(logger)\n    }\n\n    this.handleGraphChange(logEntry, logger, false)\n  }\n\n  public stop(): void {\n    this.stopLoop()\n    this.stream && this.stream.cleanUp()\n  }\n\n}\n"]} diff --git a/garden-service/build/logger/writers/file-writer.d.ts b/garden-service/build/logger/writers/file-writer.d.ts new file mode 100644 index 00000000000..3daeccf3c68 --- /dev/null +++ b/garden-service/build/logger/writers/file-writer.d.ts @@ -0,0 +1,25 @@ +import * as winston from "winston"; +import { LogLevel } from "../log-node"; +import { LogEntry } from "../log-entry"; +import { Writer } from "./base"; +export interface FileWriterConfig { + level: LogLevel; + root: string; + filename: string; + path?: string; + fileTransportOptions?: {}; + truncatePrevious?: boolean; +} +export declare class FileWriter extends Writer { + private fileLogger; + private filePath; + private fileTransportOptions; + level: LogLevel; + constructor(filePath: string, config: FileWriterConfig); + static factory(config: FileWriterConfig): Promise; + initFileLogger(): winston.Logger; + render(entry: LogEntry): string | null; + onGraphChange(entry: LogEntry): void; + stop(): void; +} +//# sourceMappingURL=file-writer.d.ts.map \ No newline at end of file diff --git a/garden-service/build/logger/writers/file-writer.js b/garden-service/build/logger/writers/file-writer.js new file mode 100644 index 00000000000..719ca17a5a6 --- /dev/null +++ b/garden-service/build/logger/writers/file-writer.js @@ -0,0 +1,87 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const winston = require("winston"); +const path_1 = require("path"); +const stripAnsi = require("strip-ansi"); +const fs_extra_1 = require("fs-extra"); +const log_node_1 = require("../log-node"); +const base_1 = require("./base"); +const util_1 = require("../util"); +const renderers_1 = require("../renderers"); +const constants_1 = require("../../constants"); +const { combine: winstonCombine, timestamp, printf } = winston.format; +const DEFAULT_FILE_TRANSPORT_OPTIONS = { + format: winstonCombine(timestamp(), printf(info => `\n[${info.timestamp}] ${info.message}`)), + maxsize: 10000000, + maxFiles: 1, +}; +const levelToStr = (lvl) => log_node_1.LogLevel[lvl]; +class FileWriter extends base_1.Writer { + constructor(filePath, config) { + const { fileTransportOptions = DEFAULT_FILE_TRANSPORT_OPTIONS, level, } = config; + super({ level }); + this.fileTransportOptions = fileTransportOptions; + this.filePath = filePath; + this.fileLogger = null; + } + static factory(config) { + return __awaiter(this, void 0, void 0, function* () { + const { filename, root, truncatePrevious, path = constants_1.LOGS_DIR, } = config; + const fullPath = path_1.join(root, path); + yield fs_extra_1.ensureDir(fullPath); + const filePath = path_1.join(fullPath, filename); + if (truncatePrevious) { + try { + yield fs_extra_1.truncate(filePath); + } + catch (_) { + } + } + return new FileWriter(filePath, config); + }); + } + // Only init if needed to prevent unnecessary file writes + initFileLogger() { + return winston.createLogger({ + level: levelToStr(this.level), + transports: [ + new winston.transports.File(Object.assign({}, this.fileTransportOptions, { filename: this.filePath })), + ], + }); + } + render(entry) { + if (util_1.validate(this.level, entry)) { + const renderFn = entry.level === log_node_1.LogLevel.error ? renderers_1.renderError : renderers_1.renderMsg; + return stripAnsi(renderFn(entry)); + } + return null; + } + onGraphChange(entry) { + const out = this.render(entry); + if (out) { + if (!this.fileLogger) { + this.fileLogger = this.initFileLogger(); + } + this.fileLogger.log(levelToStr(entry.level), out); + } + } + stop() { } +} +exports.FileWriter = FileWriter; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/plugin-context.d.ts b/garden-service/build/plugin-context.d.ts new file mode 100644 index 00000000000..045e303dc1a --- /dev/null +++ b/garden-service/build/plugin-context.d.ts @@ -0,0 +1,14 @@ +import { Garden } from "./garden"; +import * as Joi from "joi"; +import { Provider } from "./config/project"; +declare type WrappedFromGarden = Pick; +export interface PluginContext extends WrappedFromGarden { + provider: Provider; + providers: { + [name: string]: Provider; + }; +} +export declare const pluginContextSchema: Joi.ObjectSchema; +export declare function createPluginContext(garden: Garden, providerName: string): PluginContext; +export {}; +//# sourceMappingURL=plugin-context.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugin-context.js b/garden-service/build/plugin-context.js new file mode 100644 index 00000000000..200cbb51d18 --- /dev/null +++ b/garden-service/build/plugin-context.js @@ -0,0 +1,64 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const Joi = require("joi"); +const project_1 = require("./config/project"); +const common_1 = require("./config/common"); +const exceptions_1 = require("./exceptions"); +const project_2 = require("./config/project"); +const providerSchema = Joi.object() + .options({ presence: "required" }) + .keys({ + name: common_1.joiIdentifier() + .description("The name of the provider (plugin)."), + config: project_1.providerConfigBaseSchema, +}); +// NOTE: this is used more for documentation than validation, outside of internal testing +// TODO: validate the output from createPluginContext against this schema (in tests) +exports.pluginContextSchema = Joi.object() + .options({ presence: "required" }) + .keys({ + projectName: project_1.projectNameSchema, + projectRoot: Joi.string() + .uri({ relativeOnly: true }) + .description("The absolute path of the project root."), + projectSources: project_1.projectSourcesSchema, + localConfigStore: Joi.object() + .description("Helper class for managing local configuration for plugins."), + environment: project_1.environmentSchema, + provider: providerSchema + .description("The provider being used for this context."), + providers: common_1.joiIdentifierMap(providerSchema) + .description("Map of all configured providers for the current environment and project."), +}); +function createPluginContext(garden, providerName) { + const projectConfig = lodash_1.cloneDeep(garden.environment); + const providerConfigs = lodash_1.keyBy(projectConfig.providers, "name"); + const providers = lodash_1.mapValues(providerConfigs, (config, name) => ({ name, config })); + let provider = providers[providerName]; + if (providerName === "_default") { + provider = project_2.defaultProvider; + } + if (!provider) { + throw new exceptions_1.PluginError(`Could not find provider '${providerName}'`, { providerName, providers }); + } + return { + projectName: garden.projectName, + projectRoot: garden.projectRoot, + projectSources: lodash_1.cloneDeep(garden.projectSources), + environment: projectConfig, + localConfigStore: garden.localConfigStore, + provider, + providers, + }; +} +exports.createPluginContext = createPluginContext; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/plugins/container.d.ts b/garden-service/build/plugins/container.d.ts new file mode 100644 index 00000000000..0d074288d91 --- /dev/null +++ b/garden-service/build/plugins/container.d.ts @@ -0,0 +1,101 @@ +import * as Joi from "joi"; +import { Module } from "../types/module"; +import { PrimitiveMap } from "../config/common"; +import { GardenPlugin } from "../types/plugin/plugin"; +import { ValidateModuleParams } from "../types/plugin/params"; +import { Service } from "../types/service"; +import { GenericTestSpec } from "./generic"; +import { ModuleSpec, ModuleConfig } from "../config/module"; +import { BaseServiceSpec, ServiceConfig } from "../config/service"; +export interface ContainerIngressSpec { + hostname?: string; + path: string; + port: string; +} +export declare type ServicePortProtocol = "TCP" | "UDP"; +export interface ServicePortSpec { + name: string; + protocol: ServicePortProtocol; + containerPort: number; + hostPort?: number; + nodePort?: number; +} +export interface ServiceVolumeSpec { + name: string; + containerPath: string; + hostPath?: string; +} +export interface ServiceHealthCheckSpec { + httpGet?: { + path: string; + port: string; + scheme?: "HTTP" | "HTTPS"; + }; + command?: string[]; + tcpPort?: string; +} +export interface ContainerServiceSpec extends BaseServiceSpec { + command: string[]; + daemon: boolean; + ingresses: ContainerIngressSpec[]; + env: PrimitiveMap; + healthCheck?: ServiceHealthCheckSpec; + ports: ServicePortSpec[]; + volumes: ServiceVolumeSpec[]; +} +export declare type ContainerServiceConfig = ServiceConfig; +export interface ContainerRegistryConfig { + hostname: string; + port?: number; + namespace: string; +} +export declare const containerRegistryConfigSchema: Joi.ObjectSchema; +export interface ContainerService extends Service { +} +export interface ContainerTestSpec extends GenericTestSpec { +} +export declare const containerTestSchema: Joi.ObjectSchema; +export interface ContainerModuleSpec extends ModuleSpec { + buildArgs: PrimitiveMap; + image?: string; + services: ContainerServiceSpec[]; + tests: ContainerTestSpec[]; +} +export declare type ContainerModuleConfig = ModuleConfig; +export declare const defaultNamespace = "_"; +export declare const defaultTag = "latest"; +export declare const containerModuleSpecSchema: Joi.ObjectSchema; +export interface ContainerModule extends Module { +} +interface ParsedImageId { + host?: string; + namespace?: string; + repository: string; + tag: string; +} +export declare const helpers: { + /** + * Returns the image ID used locally, when building and deploying to local environments + * (when we don't need to push to remote registries). + */ + getLocalImageId(module: ContainerModule): Promise; + /** + * Returns the image ID to be used for publishing to container registries + * (not to be confused with the ID used when pushing to private deployment registries). + */ + getPublicImageId(module: ContainerModule): Promise; + /** + * Returns the image ID to be used when pushing to deployment registries. + */ + getDeploymentImageId(module: ContainerModule, registryConfig?: ContainerRegistryConfig | undefined): Promise; + parseImageId(imageId: string): ParsedImageId; + unparseImageId(parsed: ParsedImageId): string; + pullImage(module: ContainerModule): Promise; + imageExistsLocally(module: ContainerModule): Promise; + dockerCli(module: ContainerModule, args: any): Promise; + hasDockerfile(module: ContainerModule): Promise; +}; +export declare function validateContainerModule({ moduleConfig }: ValidateModuleParams): Promise>; +export declare const gardenPlugin: () => GardenPlugin; +export {}; +//# sourceMappingURL=container.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/container.js b/garden-service/build/plugins/container.js new file mode 100644 index 00000000000..b30da7d5623 --- /dev/null +++ b/garden-service/build/plugins/container.js @@ -0,0 +1,398 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const childProcess = require("child-process-promise"); +const common_1 = require("../config/common"); +const fs_extra_1 = require("fs-extra"); +const path_1 = require("path"); +const dedent = require("dedent"); +const exceptions_1 = require("../exceptions"); +const service_1 = require("../types/service"); +const constants_1 = require("../constants"); +const util_1 = require("../util/util"); +const lodash_1 = require("lodash"); +const generic_1 = require("./generic"); +const service_2 = require("../config/service"); +const ingressSchema = Joi.object() + .keys({ + hostname: service_1.ingressHostnameSchema, + path: Joi.string().uri({ relativeOnly: true }) + .default("/") + .description("The path which should be routed to the service."), + port: Joi.string() + .required() + .description("The name of the container port where the specified paths should be routed."), +}); +const healthCheckSchema = Joi.object() + .keys({ + httpGet: Joi.object() + .keys({ + path: Joi.string() + .uri({ relativeOnly: true }) + .required() + .description("The path of the service's health check endpoint."), + port: Joi.string() + .required() + .description("The name of the port where the service's health check endpoint should be available."), + scheme: Joi.string().allow("HTTP", "HTTPS").default("HTTP"), + }) + .description("Set this to check the service's health by making an HTTP request"), + command: Joi.array().items(Joi.string()) + .description("Set this to check the service's health by running a command in its container."), + tcpPort: Joi.string() + .description("Set this to check the service's health by checking if this TCP port is accepting connections."), +}).xor("httpGet", "command", "tcpPort"); +const portSchema = Joi.object() + .keys({ + name: common_1.joiIdentifier() + .required() + .description("The name of the port (used when referencing the port elsewhere in the service configuration."), + protocol: Joi.string() + .allow("TCP", "UDP") + .default(constants_1.DEFAULT_PORT_PROTOCOL) + .description("The protocol of the service container port."), + containerPort: Joi.number() + .required() + .description("The port number on the service container."), + hostPort: Joi.number() + .meta({ deprecated: true }), + nodePort: Joi.number() + .description("Set this to expose the service on the specified port on the host node " + + "(may not be supported by all providers)."), +}) + .required(); +const volumeSchema = Joi.object() + .keys({ + name: common_1.joiIdentifier() + .required() + .description("The name of the allocated volume."), + containerPath: Joi.string() + .required() + .description("The path where the volume should be mounted in the container."), + hostPath: Joi.string() + .meta({ deprecated: true }), +}); +const serviceSchema = service_2.baseServiceSchema + .keys({ + command: Joi.array().items(Joi.string()) + .description("The arguments to run the container with when starting the service."), + daemon: Joi.boolean() + .default(false) + .description("Whether to run the service as a daemon (to ensure only one runs per node)."), + ingresses: common_1.joiArray(ingressSchema) + .description("List of ingress endpoints that the service exposes.") + .example([{ + path: "/api", + port: "http", + }]), + env: common_1.joiEnvVars(), + healthCheck: healthCheckSchema + .description("Specify how the service's health should be checked after deploying."), + ports: common_1.joiArray(portSchema) + .unique("name") + .description("List of ports that the service container exposes."), + volumes: common_1.joiArray(volumeSchema) + .unique("name") + .description("List of volumes that should be mounted when deploying the container."), +}); +exports.containerRegistryConfigSchema = Joi.object() + .keys({ + hostname: Joi.string() + .hostname() + .required() + .description("The hostname (and optionally port, if not the default port) of the registry.") + .example("gcr.io"), + port: Joi.number() + .integer() + .description("The port where the registry listens on, if not the default."), + namespace: Joi.string() + .default("_") + .description("The namespace in the registry where images should be pushed.") + .example("my-project"), +}) + .required() + .description(dedent ` + The registry where built containers should be pushed to, and then pulled to the cluster when deploying + services. + `); +exports.containerTestSchema = generic_1.genericTestSchema; +exports.defaultNamespace = "_"; +exports.defaultTag = "latest"; +exports.containerModuleSpecSchema = Joi.object() + .keys({ + buildArgs: Joi.object() + .pattern(/.+/, common_1.joiPrimitive()) + .default(() => ({}), "{}") + .description("Specify build arguments when building the container image."), + // TODO: validate the image name format + image: Joi.string() + .description("Specify the image name for the container. Should be a valid docker image identifier. If specified and " + + "the module does not contain a Dockerfile, this image will be used to deploy the container services. " + + "If specified and the module does contain a Dockerfile, this identifier is used when pushing the built image."), + services: common_1.joiArray(serviceSchema) + .unique("name") + .description("List of services to deploy from this container module."), + tests: common_1.joiArray(exports.containerTestSchema) + .description("A list of tests to run in the module."), +}) + .description("Configuration for a container module."); +exports.helpers = { + /** + * Returns the image ID used locally, when building and deploying to local environments + * (when we don't need to push to remote registries). + */ + getLocalImageId(module) { + return __awaiter(this, void 0, void 0, function* () { + if (yield exports.helpers.hasDockerfile(module)) { + const { versionString } = module.version; + return `${module.name}:${versionString}`; + } + else { + return module.spec.image; + } + }); + }, + /** + * Returns the image ID to be used for publishing to container registries + * (not to be confused with the ID used when pushing to private deployment registries). + */ + getPublicImageId(module) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: allow setting a default user/org prefix in the project/plugin config + const image = module.spec.image; + if (image) { + let [imageName, version] = util_1.splitFirst(image, ":"); + if (version) { + // we use the version in the image name, if specified + // (allows specifying version on source images, and also setting specific version name when publishing images) + return image; + } + else { + const { versionString } = module.version; + return `${imageName}:${versionString}`; + } + } + else { + return exports.helpers.getLocalImageId(module); + } + }); + }, + /** + * Returns the image ID to be used when pushing to deployment registries. + */ + getDeploymentImageId(module, registryConfig) { + return __awaiter(this, void 0, void 0, function* () { + const localId = yield exports.helpers.getLocalImageId(module); + if (!registryConfig) { + return localId; + } + const parsedId = exports.helpers.parseImageId(localId); + const host = registryConfig.port ? `${registryConfig.hostname}:${registryConfig.port}` : registryConfig.hostname; + return exports.helpers.unparseImageId({ + host, + namespace: registryConfig.namespace, + repository: parsedId.repository, + tag: parsedId.tag, + }); + }); + }, + parseImageId(imageId) { + const parts = imageId.split("/"); + let [repository, tag] = parts[0].split(":"); + if (!tag) { + tag = exports.defaultTag; + } + if (parts.length === 1) { + return { + namespace: exports.defaultNamespace, + repository, + tag, + }; + } + else if (parts.length === 2) { + return { + namespace: parts[0], + repository, + tag, + }; + } + else if (parts.length === 3) { + return { + host: parts[0], + namespace: parts[1], + repository, + tag, + }; + } + else { + throw new exceptions_1.ConfigurationError(`Invalid container image tag: ${imageId}`, { imageId }); + } + }, + unparseImageId(parsed) { + const name = `${parsed.repository}:${parsed.tag}`; + if (parsed.host) { + return `${parsed.host}/${parsed.namespace}/${name}`; + } + else if (parsed.namespace) { + return `${parsed.namespace}/${name}`; + } + else { + return name; + } + }, + pullImage(module) { + return __awaiter(this, void 0, void 0, function* () { + const identifier = yield exports.helpers.getPublicImageId(module); + yield exports.helpers.dockerCli(module, `pull ${identifier}`); + }); + }, + imageExistsLocally(module) { + return __awaiter(this, void 0, void 0, function* () { + const identifier = yield exports.helpers.getLocalImageId(module); + const exists = (yield exports.helpers.dockerCli(module, `images ${identifier} -q`)).stdout.trim().length > 0; + return exists ? identifier : null; + }); + }, + dockerCli(module, args) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: use dockerode instead of CLI + return childProcess.exec("docker " + args, { cwd: module.buildPath, maxBuffer: 1024 * 1024 }); + }); + }, + hasDockerfile(module) { + return __awaiter(this, void 0, void 0, function* () { + const buildPath = module.buildPath; + return fs_extra_1.pathExists(path_1.join(buildPath, "Dockerfile")); + }); + }, +}; +function validateContainerModule({ moduleConfig }) { + return __awaiter(this, void 0, void 0, function* () { + moduleConfig.spec = common_1.validate(moduleConfig.spec, exports.containerModuleSpecSchema, { context: `module ${moduleConfig.name}` }); + // validate services + moduleConfig.serviceConfigs = moduleConfig.spec.services.map(spec => { + // make sure ports are correctly configured + const name = spec.name; + const definedPorts = spec.ports; + const portsByName = lodash_1.keyBy(spec.ports, "name"); + for (const ingress of spec.ingresses) { + const ingressPort = ingress.port; + if (!portsByName[ingressPort]) { + throw new exceptions_1.ConfigurationError(`Service ${name} does not define port ${ingressPort} defined in ingress`, { definedPorts, ingressPort }); + } + } + if (spec.healthCheck && spec.healthCheck.httpGet) { + const healthCheckHttpPort = spec.healthCheck.httpGet.port; + if (!portsByName[healthCheckHttpPort]) { + throw new exceptions_1.ConfigurationError(`Service ${name} does not define port ${healthCheckHttpPort} defined in httpGet health check`, { definedPorts, healthCheckHttpPort }); + } + } + if (spec.healthCheck && spec.healthCheck.tcpPort) { + const healthCheckTcpPort = spec.healthCheck.tcpPort; + if (!portsByName[healthCheckTcpPort]) { + throw new exceptions_1.ConfigurationError(`Service ${name} does not define port ${healthCheckTcpPort} defined in tcpPort health check`, { definedPorts, healthCheckTcpPort }); + } + } + return { + name, + dependencies: spec.dependencies, + outputs: spec.outputs, + spec, + }; + }); + moduleConfig.testConfigs = moduleConfig.spec.tests.map(t => ({ + name: t.name, + dependencies: t.dependencies, + spec: t, + timeout: t.timeout, + })); + // make sure we can build the thing + if (!moduleConfig.spec.image && !(yield fs_extra_1.pathExists(path_1.join(moduleConfig.path, "Dockerfile")))) { + throw new exceptions_1.ConfigurationError(`Module ${moduleConfig.name} neither specifies image nor provides Dockerfile`, {}); + } + return moduleConfig; + }); +} +exports.validateContainerModule = validateContainerModule; +// TODO: rename this plugin to docker +exports.gardenPlugin = () => ({ + moduleActions: { + container: { + validate: validateContainerModule, + getBuildStatus({ module, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const identifier = yield exports.helpers.imageExistsLocally(module); + if (identifier) { + logEntry && logEntry.debug({ + section: module.name, + msg: `Image ${identifier} already exists`, + symbol: "info", + }); + } + return { ready: !!identifier }; + }); + }, + build({ module, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const buildPath = module.buildPath; + const image = module.spec.image; + if (!!image && !(yield exports.helpers.hasDockerfile(module))) { + if (yield exports.helpers.imageExistsLocally(module)) { + return { fresh: false }; + } + logEntry && logEntry.setState(`Pulling image ${image}...`); + yield exports.helpers.pullImage(module); + return { fetched: true }; + } + const identifier = yield exports.helpers.getLocalImageId(module); + // build doesn't exist, so we create it + logEntry && logEntry.setState(`Building ${identifier}...`); + const buildArgs = Object.entries(module.spec.buildArgs).map(([key, value]) => { + // TODO: may need to escape this + return `--build-arg ${key}=${value}`; + }).join(" "); + // TODO: log error if it occurs + // TODO: stream output to log if at debug log level + yield exports.helpers.dockerCli(module, `build ${buildArgs} -t ${identifier} ${buildPath}`); + return { fresh: true, details: { identifier } }; + }); + }, + publishModule({ module, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + if (!(yield exports.helpers.hasDockerfile(module))) { + logEntry && logEntry.setState({ msg: `Nothing to publish` }); + return { published: false }; + } + const localId = yield exports.helpers.getLocalImageId(module); + const remoteId = yield exports.helpers.getPublicImageId(module); + logEntry && logEntry.setState({ msg: `Publishing image ${remoteId}...` }); + if (localId !== remoteId) { + yield exports.helpers.dockerCli(module, `tag ${localId} ${remoteId}`); + } + // TODO: log error if it occurs + // TODO: stream output to log if at debug log level + // TODO: check if module already exists remotely? + yield exports.helpers.dockerCli(module, `push ${remoteId}`); + return { published: true, message: `Published ${remoteId}` }; + }); + }, + }, + }, +}); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/container.ts"],"names":[],"mappings":"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","file":"plugins/container.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Joi from \"joi\"\nimport * as childProcess from \"child-process-promise\"\nimport { Module } from \"../types/module\"\nimport {\n  joiEnvVars,\n  joiIdentifier,\n  joiArray,\n  validate,\n  PrimitiveMap,\n  joiPrimitive,\n} from \"../config/common\"\nimport { pathExists } from \"fs-extra\"\nimport { join } from \"path\"\nimport dedent = require(\"dedent\")\nimport { ConfigurationError } from \"../exceptions\"\nimport {\n  GardenPlugin,\n} from \"../types/plugin/plugin\"\nimport {\n  BuildModuleParams,\n  GetBuildStatusParams,\n  ValidateModuleParams,\n  PublishModuleParams,\n} from \"../types/plugin/params\"\nimport { Service, ingressHostnameSchema } from \"../types/service\"\nimport { DEFAULT_PORT_PROTOCOL } from \"../constants\"\nimport { splitFirst } from \"../util/util\"\nimport { keyBy } from \"lodash\"\nimport { genericTestSchema, GenericTestSpec } from \"./generic\"\nimport { ModuleSpec, ModuleConfig } from \"../config/module\"\nimport { BaseServiceSpec, ServiceConfig, baseServiceSchema } from \"../config/service\"\n\nexport interface ContainerIngressSpec {\n  hostname?: string\n  path: string\n  port: string\n}\n\nexport type ServicePortProtocol = \"TCP\" | \"UDP\"\n\nexport interface ServicePortSpec {\n  name: string\n  protocol: ServicePortProtocol\n  containerPort: number\n  hostPort?: number\n  nodePort?: number\n}\n\nexport interface ServiceVolumeSpec {\n  name: string\n  containerPath: string\n  hostPath?: string\n}\n\nexport interface ServiceHealthCheckSpec {\n  httpGet?: {\n    path: string,\n    port: string,\n    scheme?: \"HTTP\" | \"HTTPS\",\n  },\n  command?: string[],\n  tcpPort?: string,\n}\n\nexport interface ContainerServiceSpec extends BaseServiceSpec {\n  command: string[],\n  daemon: boolean\n  ingresses: ContainerIngressSpec[],\n  env: PrimitiveMap,\n  healthCheck?: ServiceHealthCheckSpec,\n  ports: ServicePortSpec[],\n  volumes: ServiceVolumeSpec[],\n}\n\nexport type ContainerServiceConfig = ServiceConfig<ContainerServiceSpec>\n\nconst ingressSchema = Joi.object()\n  .keys({\n    hostname: ingressHostnameSchema,\n    path: Joi.string().uri(<any>{ relativeOnly: true })\n      .default(\"/\")\n      .description(\"The path which should be routed to the service.\"),\n    port: Joi.string()\n      .required()\n      .description(\"The name of the container port where the specified paths should be routed.\"),\n  })\n\nconst healthCheckSchema = Joi.object()\n  .keys({\n    httpGet: Joi.object()\n      .keys({\n        path: Joi.string()\n          .uri(<any>{ relativeOnly: true })\n          .required()\n          .description(\"The path of the service's health check endpoint.\"),\n        port: Joi.string()\n          .required()\n          .description(\"The name of the port where the service's health check endpoint should be available.\"),\n        scheme: Joi.string().allow(\"HTTP\", \"HTTPS\").default(\"HTTP\"),\n      })\n      .description(\"Set this to check the service's health by making an HTTP request\"),\n    command: Joi.array().items(Joi.string())\n      .description(\"Set this to check the service's health by running a command in its container.\"),\n    tcpPort: Joi.string()\n      .description(\"Set this to check the service's health by checking if this TCP port is accepting connections.\"),\n  }).xor(\"httpGet\", \"command\", \"tcpPort\")\n\nconst portSchema = Joi.object()\n  .keys({\n    name: joiIdentifier()\n      .required()\n      .description(\"The name of the port (used when referencing the port elsewhere in the service configuration.\"),\n    protocol: Joi.string()\n      .allow(\"TCP\", \"UDP\")\n      .default(DEFAULT_PORT_PROTOCOL)\n      .description(\"The protocol of the service container port.\"),\n    containerPort: Joi.number()\n      .required()\n      .description(\"The port number on the service container.\"),\n    hostPort: Joi.number()\n      .meta({ deprecated: true }),\n    nodePort: Joi.number()\n      .description(\n        \"Set this to expose the service on the specified port on the host node \" +\n        \"(may not be supported by all providers).\",\n      ),\n  })\n  .required()\n\nconst volumeSchema = Joi.object()\n  .keys({\n    name: joiIdentifier()\n      .required()\n      .description(\"The name of the allocated volume.\"),\n    containerPath: Joi.string()\n      .required()\n      .description(\"The path where the volume should be mounted in the container.\"),\n    hostPath: Joi.string()\n      .meta({ deprecated: true }),\n  })\n\nconst serviceSchema = baseServiceSchema\n  .keys({\n    command: Joi.array().items(Joi.string())\n      .description(\"The arguments to run the container with when starting the service.\"),\n    daemon: Joi.boolean()\n      .default(false)\n      .description(\"Whether to run the service as a daemon (to ensure only one runs per node).\"),\n    ingresses: joiArray(ingressSchema)\n      .description(\"List of ingress endpoints that the service exposes.\")\n      .example([{\n        path: \"/api\",\n        port: \"http\",\n      }]),\n    env: joiEnvVars(),\n    healthCheck: healthCheckSchema\n      .description(\"Specify how the service's health should be checked after deploying.\"),\n    ports: joiArray(portSchema)\n      .unique(\"name\")\n      .description(\"List of ports that the service container exposes.\"),\n    volumes: joiArray(volumeSchema)\n      .unique(\"name\")\n      .description(\"List of volumes that should be mounted when deploying the container.\"),\n  })\n\nexport interface ContainerRegistryConfig {\n  hostname: string,\n  port?: number,\n  namespace: string,\n}\n\nexport const containerRegistryConfigSchema = Joi.object()\n  .keys({\n    hostname: Joi.string()\n      .hostname()\n      .required()\n      .description(\"The hostname (and optionally port, if not the default port) of the registry.\")\n      .example(\"gcr.io\"),\n    port: Joi.number()\n      .integer()\n      .description(\"The port where the registry listens on, if not the default.\"),\n    namespace: Joi.string()\n      .default(\"_\")\n      .description(\"The namespace in the registry where images should be pushed.\")\n      .example(\"my-project\"),\n  })\n  .required()\n  .description(dedent`\n    The registry where built containers should be pushed to, and then pulled to the cluster when deploying\n    services.\n  `)\n\nexport interface ContainerService extends Service<ContainerModule> { }\n\nexport interface ContainerTestSpec extends GenericTestSpec { }\n\nexport const containerTestSchema = genericTestSchema\n\nexport interface ContainerModuleSpec extends ModuleSpec {\n  buildArgs: PrimitiveMap,\n  image?: string,\n  services: ContainerServiceSpec[],\n  tests: ContainerTestSpec[],\n}\n\nexport type ContainerModuleConfig = ModuleConfig<ContainerModuleSpec>\n\nexport const defaultNamespace = \"_\"\nexport const defaultTag = \"latest\"\n\nexport const containerModuleSpecSchema = Joi.object()\n  .keys({\n    buildArgs: Joi.object()\n      .pattern(/.+/, joiPrimitive())\n      .default(() => ({}), \"{}\")\n      .description(\"Specify build arguments when building the container image.\"),\n    // TODO: validate the image name format\n    image: Joi.string()\n      .description(\n        \"Specify the image name for the container. Should be a valid docker image identifier. If specified and \" +\n        \"the module does not contain a Dockerfile, this image will be used to deploy the container services. \" +\n        \"If specified and the module does contain a Dockerfile, this identifier is used when pushing the built image.\",\n      ),\n    services: joiArray(serviceSchema)\n      .unique(\"name\")\n      .description(\"List of services to deploy from this container module.\"),\n    tests: joiArray(containerTestSchema)\n      .description(\"A list of tests to run in the module.\"),\n  })\n  .description(\"Configuration for a container module.\")\n\nexport interface ContainerModule<\n  M extends ContainerModuleSpec = ContainerModuleSpec,\n  S extends ContainerServiceSpec = ContainerServiceSpec,\n  T extends ContainerTestSpec = ContainerTestSpec,\n  > extends Module<M, S, T> { }\n\ninterface ParsedImageId {\n  host?: string\n  namespace?: string\n  repository: string\n  tag: string\n}\n\nexport const helpers = {\n  /**\n   * Returns the image ID used locally, when building and deploying to local environments\n   * (when we don't need to push to remote registries).\n   */\n  async getLocalImageId(module: ContainerModule): Promise<string> {\n    if (await helpers.hasDockerfile(module)) {\n      const { versionString } = module.version\n      return `${module.name}:${versionString}`\n    } else {\n      return module.spec.image!\n    }\n  },\n\n  /**\n   * Returns the image ID to be used for publishing to container registries\n   * (not to be confused with the ID used when pushing to private deployment registries).\n   */\n  async getPublicImageId(module: ContainerModule) {\n    // TODO: allow setting a default user/org prefix in the project/plugin config\n    const image = module.spec.image\n\n    if (image) {\n      let [imageName, version] = splitFirst(image, \":\")\n\n      if (version) {\n        // we use the version in the image name, if specified\n        // (allows specifying version on source images, and also setting specific version name when publishing images)\n        return image\n      } else {\n        const { versionString } = module.version\n        return `${imageName}:${versionString}`\n      }\n    } else {\n      return helpers.getLocalImageId(module)\n    }\n  },\n\n  /**\n   * Returns the image ID to be used when pushing to deployment registries.\n   */\n  async getDeploymentImageId(module: ContainerModule, registryConfig?: ContainerRegistryConfig) {\n    const localId = await helpers.getLocalImageId(module)\n\n    if (!registryConfig) {\n      return localId\n    }\n\n    const parsedId = helpers.parseImageId(localId)\n\n    const host = registryConfig.port ? `${registryConfig.hostname}:${registryConfig.port}` : registryConfig.hostname\n\n    return helpers.unparseImageId({\n      host,\n      namespace: registryConfig.namespace,\n      repository: parsedId.repository,\n      tag: parsedId.tag,\n    })\n  },\n\n  parseImageId(imageId: string): ParsedImageId {\n    const parts = imageId.split(\"/\")\n    let [repository, tag] = parts[0].split(\":\")\n    if (!tag) {\n      tag = defaultTag\n    }\n\n    if (parts.length === 1) {\n      return {\n        namespace: defaultNamespace,\n        repository,\n        tag,\n      }\n    } else if (parts.length === 2) {\n      return {\n        namespace: parts[0],\n        repository,\n        tag,\n      }\n    } else if (parts.length === 3) {\n      return {\n        host: parts[0],\n        namespace: parts[1],\n        repository,\n        tag,\n      }\n    } else {\n      throw new ConfigurationError(`Invalid container image tag: ${imageId}`, { imageId })\n    }\n  },\n\n  unparseImageId(parsed: ParsedImageId) {\n    const name = `${parsed.repository}:${parsed.tag}`\n\n    if (parsed.host) {\n      return `${parsed.host}/${parsed.namespace}/${name}`\n    } else if (parsed.namespace) {\n      return `${parsed.namespace}/${name}`\n    } else {\n      return name\n    }\n  },\n\n  async pullImage(module: ContainerModule) {\n    const identifier = await helpers.getPublicImageId(module)\n    await helpers.dockerCli(module, `pull ${identifier}`)\n  },\n\n  async imageExistsLocally(module: ContainerModule) {\n    const identifier = await helpers.getLocalImageId(module)\n    const exists = (await helpers.dockerCli(module, `images ${identifier} -q`)).stdout.trim().length > 0\n    return exists ? identifier : null\n  },\n\n  async dockerCli(module: ContainerModule, args) {\n    // TODO: use dockerode instead of CLI\n    return childProcess.exec(\"docker \" + args, { cwd: module.buildPath, maxBuffer: 1024 * 1024 })\n  },\n\n  async hasDockerfile(module: ContainerModule) {\n    const buildPath = module.buildPath\n    return pathExists(join(buildPath, \"Dockerfile\"))\n  },\n}\n\nexport async function validateContainerModule({ moduleConfig }: ValidateModuleParams<ContainerModule>) {\n  moduleConfig.spec = validate(moduleConfig.spec, containerModuleSpecSchema, { context: `module ${moduleConfig.name}` })\n\n  // validate services\n  moduleConfig.serviceConfigs = moduleConfig.spec.services.map(spec => {\n    // make sure ports are correctly configured\n    const name = spec.name\n    const definedPorts = spec.ports\n    const portsByName = keyBy(spec.ports, \"name\")\n\n    for (const ingress of spec.ingresses) {\n      const ingressPort = ingress.port\n\n      if (!portsByName[ingressPort]) {\n        throw new ConfigurationError(\n          `Service ${name} does not define port ${ingressPort} defined in ingress`,\n          { definedPorts, ingressPort },\n        )\n      }\n    }\n\n    if (spec.healthCheck && spec.healthCheck.httpGet) {\n      const healthCheckHttpPort = spec.healthCheck.httpGet.port\n\n      if (!portsByName[healthCheckHttpPort]) {\n        throw new ConfigurationError(\n          `Service ${name} does not define port ${healthCheckHttpPort} defined in httpGet health check`,\n          { definedPorts, healthCheckHttpPort },\n        )\n      }\n    }\n\n    if (spec.healthCheck && spec.healthCheck.tcpPort) {\n      const healthCheckTcpPort = spec.healthCheck.tcpPort\n\n      if (!portsByName[healthCheckTcpPort]) {\n        throw new ConfigurationError(\n          `Service ${name} does not define port ${healthCheckTcpPort} defined in tcpPort health check`,\n          { definedPorts, healthCheckTcpPort },\n        )\n      }\n    }\n\n    return {\n      name,\n      dependencies: spec.dependencies,\n      outputs: spec.outputs,\n      spec,\n    }\n  })\n\n  moduleConfig.testConfigs = moduleConfig.spec.tests.map(t => ({\n    name: t.name,\n    dependencies: t.dependencies,\n    spec: t,\n    timeout: t.timeout,\n  }))\n\n  // make sure we can build the thing\n  if (!moduleConfig.spec.image && !(await pathExists(join(moduleConfig.path, \"Dockerfile\")))) {\n    throw new ConfigurationError(\n      `Module ${moduleConfig.name} neither specifies image nor provides Dockerfile`,\n      {},\n    )\n  }\n\n  return moduleConfig\n}\n\n// TODO: rename this plugin to docker\nexport const gardenPlugin = (): GardenPlugin => ({\n  moduleActions: {\n    container: {\n      validate: validateContainerModule,\n\n      async getBuildStatus({ module, logEntry }: GetBuildStatusParams<ContainerModule>) {\n        const identifier = await helpers.imageExistsLocally(module)\n\n        if (identifier) {\n          logEntry && logEntry.debug({\n            section: module.name,\n            msg: `Image ${identifier} already exists`,\n            symbol: \"info\",\n          })\n        }\n\n        return { ready: !!identifier }\n      },\n\n      async build({ module, logEntry }: BuildModuleParams<ContainerModule>) {\n        const buildPath = module.buildPath\n        const image = module.spec.image\n\n        if (!!image && !(await helpers.hasDockerfile(module))) {\n          if (await helpers.imageExistsLocally(module)) {\n            return { fresh: false }\n          }\n          logEntry && logEntry.setState(`Pulling image ${image}...`)\n          await helpers.pullImage(module)\n          return { fetched: true }\n        }\n\n        const identifier = await helpers.getLocalImageId(module)\n\n        // build doesn't exist, so we create it\n        logEntry && logEntry.setState(`Building ${identifier}...`)\n\n        const buildArgs = Object.entries(module.spec.buildArgs).map(([key, value]) => {\n          // TODO: may need to escape this\n          return `--build-arg ${key}=${value}`\n        }).join(\" \")\n\n        // TODO: log error if it occurs\n        // TODO: stream output to log if at debug log level\n        await helpers.dockerCli(module, `build ${buildArgs} -t ${identifier} ${buildPath}`)\n\n        return { fresh: true, details: { identifier } }\n      },\n\n      async publishModule({ module, logEntry }: PublishModuleParams<ContainerModule>) {\n        if (!(await helpers.hasDockerfile(module))) {\n          logEntry && logEntry.setState({ msg: `Nothing to publish` })\n          return { published: false }\n        }\n\n        const localId = await helpers.getLocalImageId(module)\n        const remoteId = await helpers.getPublicImageId(module)\n\n        logEntry && logEntry.setState({ msg: `Publishing image ${remoteId}...` })\n\n        if (localId !== remoteId) {\n          await helpers.dockerCli(module, `tag ${localId} ${remoteId}`)\n        }\n\n        // TODO: log error if it occurs\n        // TODO: stream output to log if at debug log level\n        // TODO: check if module already exists remotely?\n        await helpers.dockerCli(module, `push ${remoteId}`)\n\n        return { published: true, message: `Published ${remoteId}` }\n      },\n    },\n  },\n})\n"]} diff --git a/garden-service/build/plugins/generic.d.ts b/garden-service/build/plugins/generic.d.ts new file mode 100644 index 00000000000..f989167e9da --- /dev/null +++ b/garden-service/build/plugins/generic.d.ts @@ -0,0 +1,32 @@ +import * as Joi from "joi"; +import { GardenPlugin } from "../types/plugin/plugin"; +import { Module } from "../types/module"; +import { BuildResult, BuildStatus, ValidateModuleResult, TestResult } from "../types/plugin/outputs"; +import { BuildModuleParams, GetBuildStatusParams, ValidateModuleParams, TestModuleParams } from "../types/plugin/params"; +import { BaseServiceSpec } from "../config/service"; +import { BaseTestSpec } from "../config/test"; +import { ModuleSpec } from "../config/module"; +export declare const name = "generic"; +export interface GenericTestSpec extends BaseTestSpec { + command: string[]; + env: { + [key: string]: string; + }; +} +export declare const genericTestSchema: Joi.ObjectSchema; +export interface GenericModuleSpec extends ModuleSpec { + env: { + [key: string]: string; + }; + tests: GenericTestSpec[]; +} +export declare const genericModuleSpecSchema: Joi.ObjectSchema; +export interface GenericModule extends Module { +} +export declare function parseGenericModule({ moduleConfig }: ValidateModuleParams): Promise; +export declare function getGenericModuleBuildStatus({ module }: GetBuildStatusParams): Promise; +export declare function buildGenericModule({ module }: BuildModuleParams): Promise; +export declare function testGenericModule({ module, testConfig }: TestModuleParams): Promise; +export declare const genericPlugin: GardenPlugin; +export declare const gardenPlugin: () => GardenPlugin; +//# sourceMappingURL=generic.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/generic.js b/garden-service/build/plugins/generic.js new file mode 100644 index 00000000000..4361f4f2f2f --- /dev/null +++ b/garden-service/build/plugins/generic.js @@ -0,0 +1,126 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const lodash_1 = require("lodash"); +const path_1 = require("path"); +const common_1 = require("../config/common"); +const test_1 = require("../config/test"); +const base_1 = require("../vcs/base"); +const constants_1 = require("../constants"); +const execa = require("execa"); +exports.name = "generic"; +exports.genericTestSchema = test_1.baseTestSpecSchema + .keys({ + command: Joi.array().items(Joi.string()) + .description("The command to run in the module build context in order to test it."), + env: common_1.joiEnvVars(), +}) + .description("The test specification of a generic module."); +exports.genericModuleSpecSchema = Joi.object() + .keys({ + env: common_1.joiEnvVars(), + tests: common_1.joiArray(exports.genericTestSchema) + .description("A list of tests to run in the module."), +}) + .unknown(false) + .description("The module specification for a generic module."); +function parseGenericModule({ moduleConfig }) { + return __awaiter(this, void 0, void 0, function* () { + moduleConfig.spec = common_1.validate(moduleConfig.spec, exports.genericModuleSpecSchema, { context: `module ${moduleConfig.name}` }); + moduleConfig.testConfigs = moduleConfig.spec.tests.map(t => ({ + name: t.name, + dependencies: t.dependencies, + spec: t, + timeout: t.timeout, + })); + return moduleConfig; + }); +} +exports.parseGenericModule = parseGenericModule; +function getGenericModuleBuildStatus({ module }) { + return __awaiter(this, void 0, void 0, function* () { + const buildVersionFilePath = path_1.join(module.buildPath, constants_1.GARDEN_BUILD_VERSION_FILENAME); + let builtVersion = null; + try { + builtVersion = yield base_1.readModuleVersionFile(buildVersionFilePath); + } + catch (_) { + // just ignore this error, can be caused by an outdated format + } + if (builtVersion && builtVersion.versionString === module.version.versionString) { + return { ready: true }; + } + return { ready: false }; + }); +} +exports.getGenericModuleBuildStatus = getGenericModuleBuildStatus; +function buildGenericModule({ module }) { + return __awaiter(this, void 0, void 0, function* () { + const config = module; + const output = {}; + const buildPath = module.buildPath; + if (config.build.command.length) { + const res = yield execa.shell(config.build.command.join(" "), { + cwd: buildPath, + env: Object.assign({}, process.env, lodash_1.mapValues(module.spec.env, v => v.toString())), + }); + output.fresh = true; + output.buildLog = res.stdout + res.stderr; + } + // keep track of which version has been built + const buildVersionFilePath = path_1.join(buildPath, constants_1.GARDEN_BUILD_VERSION_FILENAME); + yield base_1.writeModuleVersionFile(buildVersionFilePath, module.version); + return output; + }); +} +exports.buildGenericModule = buildGenericModule; +function testGenericModule({ module, testConfig }) { + return __awaiter(this, void 0, void 0, function* () { + const startedAt = new Date(); + const command = testConfig.spec.command; + const result = yield execa.shell(command.join(" "), { + cwd: module.path, + env: Object.assign({}, process.env, lodash_1.mapValues(module.spec.env, v => v + ""), lodash_1.mapValues(testConfig.spec.env, v => v + "")), + reject: false, + }); + return { + moduleName: module.name, + command, + testName: testConfig.name, + version: module.version, + success: result.code === 0, + startedAt, + completedAt: new Date(), + output: result.stdout + result.stderr, + }; + }); +} +exports.testGenericModule = testGenericModule; +exports.genericPlugin = { + moduleActions: { + generic: { + validate: parseGenericModule, + getBuildStatus: getGenericModuleBuildStatus, + build: buildGenericModule, + testModule: testGenericModule, + }, + }, +}; +exports.gardenPlugin = () => exports.genericPlugin; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/generic.ts"],"names":[],"mappings":"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","file":"plugins/generic.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Joi from \"joi\"\nimport { mapValues } from \"lodash\"\nimport { join } from \"path\"\nimport {\n  joiArray,\n  joiEnvVars,\n  validate,\n} from \"../config/common\"\nimport {\n  GardenPlugin,\n} from \"../types/plugin/plugin\"\nimport { Module } from \"../types/module\"\nimport {\n  BuildResult,\n  BuildStatus,\n  ValidateModuleResult,\n  TestResult,\n} from \"../types/plugin/outputs\"\nimport {\n  BuildModuleParams,\n  GetBuildStatusParams,\n  ValidateModuleParams,\n  TestModuleParams,\n} from \"../types/plugin/params\"\nimport { BaseServiceSpec } from \"../config/service\"\nimport { BaseTestSpec, baseTestSpecSchema } from \"../config/test\"\nimport { readModuleVersionFile, writeModuleVersionFile, ModuleVersion } from \"../vcs/base\"\nimport { GARDEN_BUILD_VERSION_FILENAME } from \"../constants\"\nimport { ModuleSpec, ModuleConfig } from \"../config/module\"\nimport execa = require(\"execa\")\n\nexport const name = \"generic\"\n\nexport interface GenericTestSpec extends BaseTestSpec {\n  command: string[],\n  env: { [key: string]: string },\n}\n\nexport const genericTestSchema = baseTestSpecSchema\n  .keys({\n    command: Joi.array().items(Joi.string())\n      .description(\"The command to run in the module build context in order to test it.\"),\n    env: joiEnvVars(),\n  })\n  .description(\"The test specification of a generic module.\")\n\nexport interface GenericModuleSpec extends ModuleSpec {\n  env: { [key: string]: string },\n  tests: GenericTestSpec[],\n}\n\nexport const genericModuleSpecSchema = Joi.object()\n  .keys({\n    env: joiEnvVars(),\n    tests: joiArray(genericTestSchema)\n      .description(\"A list of tests to run in the module.\"),\n  })\n  .unknown(false)\n  .description(\"The module specification for a generic module.\")\n\nexport interface GenericModule extends Module<GenericModuleSpec, BaseServiceSpec, GenericTestSpec> { }\n\nexport async function parseGenericModule(\n  { moduleConfig }: ValidateModuleParams<GenericModule>,\n): Promise<ValidateModuleResult> {\n  moduleConfig.spec = validate(moduleConfig.spec, genericModuleSpecSchema, { context: `module ${moduleConfig.name}` })\n\n  moduleConfig.testConfigs = moduleConfig.spec.tests.map(t => ({\n    name: t.name,\n    dependencies: t.dependencies,\n    spec: t,\n    timeout: t.timeout,\n  }))\n\n  return moduleConfig\n}\n\nexport async function getGenericModuleBuildStatus({ module }: GetBuildStatusParams): Promise<BuildStatus> {\n  const buildVersionFilePath = join(module.buildPath, GARDEN_BUILD_VERSION_FILENAME)\n  let builtVersion: ModuleVersion | null = null\n\n  try {\n    builtVersion = await readModuleVersionFile(buildVersionFilePath)\n  } catch (_) {\n    // just ignore this error, can be caused by an outdated format\n  }\n\n  if (builtVersion && builtVersion.versionString === module.version.versionString) {\n    return { ready: true }\n  }\n\n  return { ready: false }\n}\n\nexport async function buildGenericModule({ module }: BuildModuleParams<GenericModule>): Promise<BuildResult> {\n  const config: ModuleConfig = module\n  const output: BuildResult = {}\n  const buildPath = module.buildPath\n\n  if (config.build.command.length) {\n    const res = await execa.shell(\n      config.build.command.join(\" \"),\n      {\n        cwd: buildPath,\n        env: { ...process.env, ...mapValues(module.spec.env, v => v.toString()) },\n      },\n    )\n\n    output.fresh = true\n    output.buildLog = res.stdout + res.stderr\n  }\n\n  // keep track of which version has been built\n  const buildVersionFilePath = join(buildPath, GARDEN_BUILD_VERSION_FILENAME)\n  await writeModuleVersionFile(buildVersionFilePath, module.version)\n\n  return output\n}\n\nexport async function testGenericModule({ module, testConfig }: TestModuleParams<GenericModule>): Promise<TestResult> {\n  const startedAt = new Date()\n  const command = testConfig.spec.command\n\n  const result = await execa.shell(\n    command.join(\" \"),\n    {\n      cwd: module.path,\n      env: {\n        ...process.env,\n        // need to cast the values to strings\n        ...mapValues(module.spec.env, v => v + \"\"),\n        ...mapValues(testConfig.spec.env, v => v + \"\"),\n      },\n      reject: false,\n    },\n  )\n\n  return {\n    moduleName: module.name,\n    command,\n    testName: testConfig.name,\n    version: module.version,\n    success: result.code === 0,\n    startedAt,\n    completedAt: new Date(),\n    output: result.stdout + result.stderr,\n  }\n}\n\nexport const genericPlugin: GardenPlugin = {\n  moduleActions: {\n    generic: {\n      validate: parseGenericModule,\n      getBuildStatus: getGenericModuleBuildStatus,\n      build: buildGenericModule,\n      testModule: testGenericModule,\n    },\n  },\n}\n\nexport const gardenPlugin = () => genericPlugin\n"]} diff --git a/garden-service/build/plugins/google/common.d.ts b/garden-service/build/plugins/google/common.d.ts new file mode 100644 index 00000000000..8ece96d5f44 --- /dev/null +++ b/garden-service/build/plugins/google/common.d.ts @@ -0,0 +1,27 @@ +import { Module } from "../../types/module"; +import { PrepareEnvironmentParams } from "../../types/plugin/params"; +import { Service } from "../../types/service"; +import { GenericTestSpec } from "../generic"; +import { GCloud } from "./gcloud"; +import { ModuleSpec } from "../../config/module"; +import { BaseServiceSpec } from "../../config/service"; +import { Provider } from "../../config/project"; +export declare const GOOGLE_CLOUD_DEFAULT_REGION = "us-central1"; +export interface GoogleCloudServiceSpec extends BaseServiceSpec { + project?: string; +} +export interface GoogleCloudModule extends Module { +} +export declare function getEnvironmentStatus(): Promise<{ + ready: boolean; + detail: { + sdkInstalled: boolean; + sdkInitialized: boolean; + betaComponentsInstalled: boolean; + sdkInfo: {}; + }; +}>; +export declare function prepareEnvironment({ status, logEntry }: PrepareEnvironmentParams): Promise<{}>; +export declare function gcloud(project?: string, account?: string): GCloud; +export declare function getProject(service: Service, provider: Provider): any; +//# sourceMappingURL=common.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/google/common.js b/garden-service/build/plugins/google/common.js new file mode 100644 index 00000000000..b55d26412bf --- /dev/null +++ b/garden-service/build/plugins/google/common.js @@ -0,0 +1,86 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const exceptions_1 = require("../../exceptions"); +const gcloud_1 = require("./gcloud"); +exports.GOOGLE_CLOUD_DEFAULT_REGION = "us-central1"; +function getEnvironmentStatus() { + return __awaiter(this, void 0, void 0, function* () { + let sdkInfo; + const output = { + ready: true, + detail: { + sdkInstalled: true, + sdkInitialized: true, + betaComponentsInstalled: true, + sdkInfo: {}, + }, + }; + try { + sdkInfo = output.detail.sdkInfo = yield gcloud().json(["info"]); + } + catch (err) { + output.ready = false; + output.detail.sdkInstalled = false; + } + if (!sdkInfo.config.account) { + output.ready = false; + output.detail.sdkInitialized = false; + } + if (!sdkInfo.installation.components.beta) { + output.ready = false; + output.detail.betaComponentsInstalled = false; + } + return output; + }); +} +exports.getEnvironmentStatus = getEnvironmentStatus; +function prepareEnvironment({ status, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + if (!status.detail.sdkInstalled) { + throw new exceptions_1.ConfigurationError("Google Cloud SDK is not installed. " + + "Please visit https://cloud.google.com/sdk/downloads for installation instructions.", {}); + } + if (!status.detail.betaComponentsInstalled) { + logEntry && logEntry.info({ + section: "google-cloud-functions", + msg: `Installing gcloud SDK beta components...`, + }); + yield gcloud().call(["components update"]); + yield gcloud().call(["components install beta"]); + } + if (!status.detail.sdkInitialized) { + logEntry && logEntry.info({ + section: "google-cloud-functions", + msg: `Initializing SDK...`, + }); + yield gcloud().tty(["init"], { silent: false }); + } + return {}; + }); +} +exports.prepareEnvironment = prepareEnvironment; +function gcloud(project, account) { + return new gcloud_1.GCloud({ project, account }); +} +exports.gcloud = gcloud; +function getProject(service, provider) { + return service.spec.project || provider.config["default-project"] || null; +} +exports.getProject = getProject; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/plugins/google/gcloud.d.ts b/garden-service/build/plugins/google/gcloud.d.ts new file mode 100644 index 00000000000..052a9f980aa --- /dev/null +++ b/garden-service/build/plugins/google/gcloud.d.ts @@ -0,0 +1,30 @@ +/// +export interface GCloudParams { + data?: Buffer; + ignoreError?: boolean; + silent?: boolean; + timeout?: number; + cwd?: string; +} +export interface GCloudOutput { + code: number; + output: string; + stdout?: string; + stderr?: string; +} +export declare class GCloud { + account?: string; + project?: string; + constructor({ account, project }: { + account?: string; + project?: string; + }); + call(args: string[], { data, ignoreError, silent, timeout, cwd }?: GCloudParams): Promise; + json(args: string[], opts?: GCloudParams): Promise; + tty(args: string[], { silent, cwd }?: { + silent?: boolean; + cwd?: string; + }): Promise; + private prepareArgs; +} +//# sourceMappingURL=gcloud.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/google/gcloud.js b/garden-service/build/plugins/google/gcloud.js new file mode 100644 index 00000000000..d2de17c1b1f --- /dev/null +++ b/garden-service/build/plugins/google/gcloud.js @@ -0,0 +1,107 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const child_process_1 = require("child_process"); +const lodash_1 = require("lodash"); +const util_1 = require("../../util/util"); +const DEFAULT_TIMEOUT = 600; +// TODO: re-use code across this and Kubectl +class GCloud { + constructor({ account, project }) { + this.account = account; + this.project = project; + } + call(args, { data, ignoreError = false, silent = true, timeout = DEFAULT_TIMEOUT, cwd } = {}) { + return __awaiter(this, void 0, void 0, function* () { + const out = { + code: 0, + output: "", + stdout: "", + stderr: "", + }; + const proc = child_process_1.spawn("gcloud", this.prepareArgs(args), { cwd }); + proc.stdout.on("data", (s) => { + if (!silent) { + process.stdout.write(s); + } + out.output += s; + out.stdout += s; + }); + proc.stderr.on("data", (s) => { + if (!silent) { + process.stderr.write(s); + } + out.output += s; + out.stderr += s; + }); + if (data) { + proc.stdin.end(data); + } + return new Promise((resolve, reject) => { + let _timeout; + const _reject = (msg) => { + const err = new Error(msg); + lodash_1.extend(err, out); + reject(err); + }; + if (timeout > 0) { + _timeout = setTimeout(() => { + proc.kill("SIGKILL"); + _reject(`gcloud timed out after ${timeout} seconds.`); + }, timeout * 1000); + } + proc.on("close", (code) => { + _timeout && clearTimeout(_timeout); + out.code = code; + if (code === 0 || ignoreError) { + resolve(out); + } + else { + _reject("Process exited with code " + code); + } + }); + }); + }); + } + json(args, opts = {}) { + return __awaiter(this, void 0, void 0, function* () { + if (!args.includes("--format=json")) { + args.push("--format=json"); + } + const result = yield this.call(args, opts); + return JSON.parse(result.output); + }); + } + tty(args, { silent = true, cwd } = {}) { + return __awaiter(this, void 0, void 0, function* () { + return util_1.spawnPty("gcloud", this.prepareArgs(args), { silent, cwd, tty: true }); + }); + } + prepareArgs(args) { + const ops = []; + if (this.account) { + ops.push(`--account=${this.account}`); + } + if (this.project) { + ops.push(`--project=${this.project}`); + } + return ops.concat(args); + } +} +exports.GCloud = GCloud; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/google/gcloud.ts"],"names":[],"mappings":"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","file":"plugins/google/gcloud.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { spawn } from \"child_process\"\nimport { extend } from \"lodash\"\nimport { spawnPty } from \"../../util/util\"\n\nexport interface GCloudParams {\n  data?: Buffer,\n  ignoreError?: boolean,\n  silent?: boolean,\n  timeout?: number,\n  cwd?: string,\n}\n\nexport interface GCloudOutput {\n  code: number,\n  output: string,\n  stdout?: string,\n  stderr?: string,\n}\n\nconst DEFAULT_TIMEOUT = 600\n\n// TODO: re-use code across this and Kubectl\nexport class GCloud {\n  public account?: string\n  public project?: string\n\n  constructor({ account, project }: { account?: string, project?: string }) {\n    this.account = account\n    this.project = project\n  }\n\n  async call(\n    args: string[],\n    { data, ignoreError = false, silent = true, timeout = DEFAULT_TIMEOUT, cwd }: GCloudParams = {},\n  ): Promise<GCloudOutput> {\n\n    const out: GCloudOutput = {\n      code: 0,\n      output: \"\",\n      stdout: \"\",\n      stderr: \"\",\n    }\n\n    const proc = spawn(\"gcloud\", this.prepareArgs(args), { cwd })\n\n    proc.stdout.on(\"data\", (s) => {\n      if (!silent) {\n        process.stdout.write(s)\n      }\n      out.output += s\n      out.stdout! += s\n    })\n\n    proc.stderr.on(\"data\", (s) => {\n      if (!silent) {\n        process.stderr.write(s)\n      }\n      out.output += s\n      out.stderr! += s\n    })\n\n    if (data) {\n      proc.stdin.end(data)\n    }\n\n    return new Promise<GCloudOutput>((resolve, reject) => {\n      let _timeout\n\n      const _reject = (msg: string) => {\n        const err = new Error(msg)\n        extend(err, <any>out)\n        reject(err)\n      }\n\n      if (timeout > 0) {\n        _timeout = setTimeout(() => {\n          proc.kill(\"SIGKILL\")\n          _reject(`gcloud timed out after ${timeout} seconds.`)\n        }, timeout * 1000)\n      }\n\n      proc.on(\"close\", (code) => {\n        _timeout && clearTimeout(_timeout)\n        out.code = code\n\n        if (code === 0 || ignoreError) {\n          resolve(out)\n        } else {\n          _reject(\"Process exited with code \" + code)\n        }\n      })\n    })\n  }\n\n  async json(args: string[], opts: GCloudParams = {}): Promise<any> {\n    if (!args.includes(\"--format=json\")) {\n      args.push(\"--format=json\")\n    }\n\n    const result = await this.call(args, opts)\n\n    return JSON.parse(result.output)\n  }\n\n  async tty(args: string[], { silent = true, cwd }: { silent?: boolean, cwd?: string } = {}): Promise<GCloudOutput> {\n    return spawnPty(\"gcloud\", this.prepareArgs(args), { silent, cwd, tty: true })\n  }\n\n  private prepareArgs(args: string[]) {\n    const ops: string[] = []\n\n    if (this.account) {\n      ops.push(`--account=${this.account}`)\n    }\n\n    if (this.project) {\n      ops.push(`--project=${this.project}`)\n    }\n\n    return ops.concat(args)\n  }\n}\n"]} diff --git a/garden-service/build/plugins/google/google-app-engine.d.ts b/garden-service/build/plugins/google/google-app-engine.d.ts new file mode 100644 index 00000000000..3896dc9fdfb --- /dev/null +++ b/garden-service/build/plugins/google/google-app-engine.d.ts @@ -0,0 +1,9 @@ +import { ContainerModule, ContainerModuleSpec, ContainerServiceSpec } from "../container"; +import { GardenPlugin } from "../../types/plugin/plugin"; +export interface GoogleAppEngineServiceSpec extends ContainerServiceSpec { + project?: string; +} +export interface GoogleAppEngineModule extends ContainerModule { +} +export declare const gardenPlugin: () => GardenPlugin; +//# sourceMappingURL=google-app-engine.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/google/google-app-engine.js b/garden-service/build/plugins/google/google-app-engine.js new file mode 100644 index 00000000000..86d9f720da7 --- /dev/null +++ b/garden-service/build/plugins/google/google-app-engine.js @@ -0,0 +1,90 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const common_1 = require("./common"); +const common_2 = require("./common"); +const util_1 = require("../../util/util"); +exports.gardenPlugin = () => ({ + actions: { + getEnvironmentStatus: common_2.getEnvironmentStatus, + prepareEnvironment: common_2.prepareEnvironment, + }, + moduleActions: { + container: { + getServiceStatus() { + return __awaiter(this, void 0, void 0, function* () { + // TODO + // const project = this.getProject(service, env) + // + // const appStatus = await this.gcloud(project).json(["app", "describe"]) + // const services = await this.gcloud(project).json(["app", "services", "list"]) + // const instances: any[] = await this.gcloud(project).json(["app", "instances", "list"]) + return {}; + }); + }, + deployService({ ctx, service, runtimeContext, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + logEntry && logEntry.info({ + section: service.name, + msg: `Deploying app...`, + }); + const config = service.spec; + // prepare app.yaml + const appYaml = { + runtime: "custom", + env: "flex", + env_variables: Object.assign({}, runtimeContext.envVars, service.spec.env), + }; + if (config.healthCheck) { + if (config.healthCheck.tcpPort || config.healthCheck.command) { + logEntry && logEntry.warn({ + section: service.name, + msg: "GAE only supports httpGet health checks", + }); + } + if (config.healthCheck.httpGet) { + appYaml.liveness_check = { path: config.healthCheck.httpGet.path }; + appYaml.readiness_check = { path: config.healthCheck.httpGet.path }; + } + } + // write app.yaml to build context + const appYamlPath = path_1.join(service.module.path, "app.yaml"); + yield util_1.dumpYaml(appYamlPath, appYaml); + // deploy to GAE + const project = common_1.getProject(service, ctx.provider); + yield common_1.gcloud(project).call([ + "app", "deploy", "--quiet", + ], { cwd: service.module.path }); + logEntry && logEntry.info({ section: service.name, msg: `App deployed` }); + return {}; + }); + }, + getServiceOutputs({ ctx, service }) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: we may want to pull this from the service status instead, along with other outputs + const project = common_1.getProject(service, ctx.provider); + return { + ingress: `https://${common_2.GOOGLE_CLOUD_DEFAULT_REGION}-${project}.cloudfunctions.net/${service.name}`, + }; + }); + }, + }, + }, +}); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/plugins/google/google-cloud-functions.d.ts b/garden-service/build/plugins/google/google-cloud-functions.d.ts new file mode 100644 index 00000000000..079b968f16a --- /dev/null +++ b/garden-service/build/plugins/google/google-cloud-functions.d.ts @@ -0,0 +1,26 @@ +import { Module } from "../../types/module"; +import { ValidateModuleResult } from "../../types/plugin/outputs"; +import { GetServiceStatusParams, ValidateModuleParams } from "../../types/plugin/params"; +import { ServiceStatus } from "../../types/service"; +import * as Joi from "joi"; +import { GenericTestSpec } from "../generic"; +import { GoogleCloudServiceSpec } from "./common"; +import { GardenPlugin } from "../../types/plugin/plugin"; +import { ModuleSpec } from "../../config/module"; +export interface GcfServiceSpec extends GoogleCloudServiceSpec { + entrypoint?: string; + function: string; + hostname?: string; + path: string; +} +export declare const gcfServicesSchema: Joi.ArraySchema; +export interface GcfModuleSpec extends ModuleSpec { + functions: GcfServiceSpec[]; + tests: GenericTestSpec[]; +} +export interface GcfModule extends Module { +} +export declare function parseGcfModule({ moduleConfig }: ValidateModuleParams): Promise>; +export declare const gardenPlugin: () => GardenPlugin; +export declare function getServiceStatus({ ctx, service }: GetServiceStatusParams): Promise; +//# sourceMappingURL=google-cloud-functions.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/google/google-cloud-functions.js b/garden-service/build/plugins/google/google-cloud-functions.js new file mode 100644 index 00000000000..2a3f792092a --- /dev/null +++ b/garden-service/build/plugins/google/google-cloud-functions.js @@ -0,0 +1,128 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const common_1 = require("../../config/common"); +const service_1 = require("../../types/service"); +const path_1 = require("path"); +const Joi = require("joi"); +const constants_1 = require("../../constants"); +const generic_1 = require("../generic"); +const common_2 = require("./common"); +const service_2 = require("../../config/service"); +const gcfServiceSchema = service_2.baseServiceSchema + .keys({ + entrypoint: Joi.string() + .description("The entrypoint for the function (exported name in the function's module)"), + hostname: service_1.ingressHostnameSchema, + path: Joi.string() + .default(".") + .description("The path of the module that contains the function."), + project: Joi.string() + .description("The Google Cloud project name of the function."), +}) + .description("Configuration for a Google Cloud Function."); +exports.gcfServicesSchema = common_1.joiArray(gcfServiceSchema) + .min(1) + .unique("name") + .description("List of configurations for one or more Google Cloud Functions."); +const gcfModuleSpecSchema = Joi.object() + .keys({ + functions: exports.gcfServicesSchema, + tests: common_1.joiArray(generic_1.genericTestSchema), +}); +function parseGcfModule({ moduleConfig }) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: check that each function exists at the specified path + moduleConfig.spec = common_1.validate(moduleConfig.spec, gcfModuleSpecSchema, { context: `module ${moduleConfig.name}` }); + moduleConfig.serviceConfigs = moduleConfig.spec.functions.map(f => ({ + name: f.name, + dependencies: f.dependencies, + outputs: f.outputs, + spec: f, + })); + moduleConfig.testConfigs = moduleConfig.spec.tests.map(t => ({ + name: t.name, + dependencies: t.dependencies, + timeout: t.timeout, + spec: t, + })); + return moduleConfig; + }); +} +exports.parseGcfModule = parseGcfModule; +exports.gardenPlugin = () => ({ + actions: { + getEnvironmentStatus: common_2.getEnvironmentStatus, + prepareEnvironment: common_2.prepareEnvironment, + }, + moduleActions: { + "google-cloud-function": { + validate: parseGcfModule, + deployService({ ctx, module, service, runtimeContext, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: provide env vars somehow to function + const project = common_2.getProject(service, ctx.provider); + const functionPath = path_1.resolve(service.module.path, service.spec.path); + const entrypoint = service.spec.entrypoint || service.name; + yield common_2.gcloud(project).call([ + "beta", "functions", + "deploy", service.name, + `--source=${functionPath}`, + `--entry-point=${entrypoint}`, + // TODO: support other trigger types + "--trigger-http", + ]); + return getServiceStatus({ ctx, module, service, runtimeContext, logEntry }); + }); + }, + getServiceOutputs({ ctx, service }) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: we may want to pull this from the service status instead, along with other outputs + const project = common_2.getProject(service, ctx.provider); + return { + ingress: `https://${common_2.GOOGLE_CLOUD_DEFAULT_REGION}-${project}.cloudfunctions.net/${service.name}`, + }; + }); + }, + }, + }, +}); +function getServiceStatus({ ctx, service }) { + return __awaiter(this, void 0, void 0, function* () { + const project = common_2.getProject(service, ctx.provider); + const functions = yield common_2.gcloud(project).json(["beta", "functions", "list"]); + const providerId = `projects/${project}/locations/${common_2.GOOGLE_CLOUD_DEFAULT_REGION}/functions/${service.name}`; + const status = functions.filter(f => f.name === providerId)[0]; + if (!status) { + // not deployed yet + return {}; + } + // TODO: map states properly + const state = status.status === "ACTIVE" ? "ready" : "unhealthy"; + return { + providerId, + providerVersion: status.versionId, + version: status.labels[constants_1.GARDEN_ANNOTATION_KEYS_VERSION], + state, + updatedAt: status.updateTime, + detail: status, + }; + }); +} +exports.getServiceStatus = getServiceStatus; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/google/google-cloud-functions.ts"],"names":[],"mappings":"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","file":"plugins/google/google-cloud-functions.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport {\n  joiArray,\n  validate,\n} from \"../../config/common\"\nimport { Module } from \"../../types/module\"\nimport { ValidateModuleResult } from \"../../types/plugin/outputs\"\nimport {\n  DeployServiceParams,\n  GetServiceOutputsParams,\n  GetServiceStatusParams,\n  ValidateModuleParams,\n} from \"../../types/plugin/params\"\nimport { ServiceState, ServiceStatus, ingressHostnameSchema } from \"../../types/service\"\nimport {\n  resolve,\n} from \"path\"\nimport * as Joi from \"joi\"\nimport { GARDEN_ANNOTATION_KEYS_VERSION } from \"../../constants\"\nimport { GenericTestSpec, genericTestSchema } from \"../generic\"\nimport {\n  prepareEnvironment,\n  gcloud,\n  getEnvironmentStatus,\n  getProject,\n  GOOGLE_CLOUD_DEFAULT_REGION,\n  GoogleCloudServiceSpec,\n} from \"./common\"\nimport { GardenPlugin } from \"../../types/plugin/plugin\"\nimport { ModuleSpec } from \"../../config/module\"\nimport { baseServiceSchema } from \"../../config/service\"\n\nexport interface GcfServiceSpec extends GoogleCloudServiceSpec {\n  entrypoint?: string,\n  function: string,\n  hostname?: string\n  path: string,\n}\n\nconst gcfServiceSchema = baseServiceSchema\n  .keys({\n    entrypoint: Joi.string()\n      .description(\"The entrypoint for the function (exported name in the function's module)\"),\n    hostname: ingressHostnameSchema,\n    path: Joi.string()\n      .default(\".\")\n      .description(\"The path of the module that contains the function.\"),\n    project: Joi.string()\n      .description(\"The Google Cloud project name of the function.\"),\n  })\n  .description(\"Configuration for a Google Cloud Function.\")\n\nexport const gcfServicesSchema = joiArray(gcfServiceSchema)\n  .min(1)\n  .unique(\"name\")\n  .description(\"List of configurations for one or more Google Cloud Functions.\")\n\nexport interface GcfModuleSpec extends ModuleSpec {\n  functions: GcfServiceSpec[],\n  tests: GenericTestSpec[],\n}\n\nconst gcfModuleSpecSchema = Joi.object()\n  .keys({\n    functions: gcfServicesSchema,\n    tests: joiArray(genericTestSchema),\n  })\n\nexport interface GcfModule extends Module<GcfModuleSpec, GcfServiceSpec, GenericTestSpec> { }\n\nexport async function parseGcfModule(\n  { moduleConfig }: ValidateModuleParams<GcfModule>,\n): Promise<ValidateModuleResult<GcfModule>> {\n  // TODO: check that each function exists at the specified path\n  moduleConfig.spec = validate(\n    moduleConfig.spec, gcfModuleSpecSchema, { context: `module ${moduleConfig.name}` },\n  )\n\n  moduleConfig.serviceConfigs = moduleConfig.spec.functions.map(f => ({\n    name: f.name,\n    dependencies: f.dependencies,\n    outputs: f.outputs,\n    spec: f,\n  }))\n\n  moduleConfig.testConfigs = moduleConfig.spec.tests.map(t => ({\n    name: t.name,\n    dependencies: t.dependencies,\n    timeout: t.timeout,\n    spec: t,\n  }))\n\n  return moduleConfig\n}\n\nexport const gardenPlugin = (): GardenPlugin => ({\n  actions: {\n    getEnvironmentStatus,\n    prepareEnvironment,\n  },\n  moduleActions: {\n    \"google-cloud-function\": {\n      validate: parseGcfModule,\n\n      async deployService(\n        { ctx, module, service, runtimeContext, logEntry }: DeployServiceParams<GcfModule>,\n      ) {\n        // TODO: provide env vars somehow to function\n        const project = getProject(service, ctx.provider)\n        const functionPath = resolve(service.module.path, service.spec.path)\n        const entrypoint = service.spec.entrypoint || service.name\n\n        await gcloud(project).call([\n          \"beta\", \"functions\",\n          \"deploy\", service.name,\n          `--source=${functionPath}`,\n          `--entry-point=${entrypoint}`,\n          // TODO: support other trigger types\n          \"--trigger-http\",\n        ])\n\n        return getServiceStatus({ ctx, module, service, runtimeContext, logEntry })\n      },\n\n      async getServiceOutputs({ ctx, service }: GetServiceOutputsParams<GcfModule>) {\n        // TODO: we may want to pull this from the service status instead, along with other outputs\n        const project = getProject(service, ctx.provider)\n\n        return {\n          ingress: `https://${GOOGLE_CLOUD_DEFAULT_REGION}-${project}.cloudfunctions.net/${service.name}`,\n        }\n      },\n    },\n  },\n})\n\nexport async function getServiceStatus(\n  { ctx, service }: GetServiceStatusParams<GcfModule>,\n): Promise<ServiceStatus> {\n  const project = getProject(service, ctx.provider)\n  const functions: any[] = await gcloud(project).json([\"beta\", \"functions\", \"list\"])\n  const providerId = `projects/${project}/locations/${GOOGLE_CLOUD_DEFAULT_REGION}/functions/${service.name}`\n\n  const status = functions.filter(f => f.name === providerId)[0]\n\n  if (!status) {\n    // not deployed yet\n    return {}\n  }\n\n  // TODO: map states properly\n  const state: ServiceState = status.status === \"ACTIVE\" ? \"ready\" : \"unhealthy\"\n\n  return {\n    providerId,\n    providerVersion: status.versionId,\n    version: status.labels[GARDEN_ANNOTATION_KEYS_VERSION],\n    state,\n    updatedAt: status.updateTime,\n    detail: status,\n  }\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/actions.d.ts b/garden-service/build/plugins/kubernetes/actions.d.ts new file mode 100644 index 00000000000..6becfa24025 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/actions.d.ts @@ -0,0 +1,20 @@ +import { GetServiceLogsResult, RunResult, TestResult } from "../../types/plugin/outputs"; +import { ExecInServiceParams, GetServiceLogsParams, GetServiceOutputsParams, GetTestResultParams, RunModuleParams, TestModuleParams, DeleteServiceParams, RunServiceParams } from "../../types/plugin/params"; +import { ContainerModule } from "../container"; +import { ServiceStatus } from "../../types/service"; +import { ValidateModuleParams } from "../../types/plugin/params"; +export declare function validate(params: ValidateModuleParams): Promise; +export declare function deleteService(params: DeleteServiceParams): Promise; +export declare function getServiceOutputs({ service }: GetServiceOutputsParams): Promise<{ + host: string; +}>; +export declare function execInService(params: ExecInServiceParams): Promise<{ + code: number; + output: string; +}>; +export declare function runModule({ ctx, module, command, interactive, runtimeContext, silent, timeout }: RunModuleParams): Promise; +export declare function runService({ ctx, service, interactive, runtimeContext, silent, timeout, logEntry }: RunServiceParams): Promise; +export declare function testModule({ ctx, interactive, module, runtimeContext, silent, testConfig, logEntry }: TestModuleParams): Promise; +export declare function getTestResult({ ctx, module, testName, version }: GetTestResultParams): Promise; +export declare function getServiceLogs({ ctx, service, stream, tail }: GetServiceLogsParams): Promise; +//# sourceMappingURL=actions.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/actions.js b/garden-service/build/plugins/kubernetes/actions.js new file mode 100644 index 00000000000..fd142572d5c --- /dev/null +++ b/garden-service/build/plugins/kubernetes/actions.js @@ -0,0 +1,268 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const split = require("split"); +const moment = require("moment"); +const exceptions_1 = require("../../exceptions"); +const container_1 = require("../container"); +const util_1 = require("../../util/util"); +const api_1 = require("./api"); +const namespace_1 = require("./namespace"); +const kubectl_1 = require("./kubectl"); +const constants_1 = require("../../constants"); +const deployment_1 = require("./deployment"); +function validate(params) { + return __awaiter(this, void 0, void 0, function* () { + const config = yield container_1.validateContainerModule(params); + // validate ingress specs + const provider = params.ctx.provider; + for (const serviceConfig of config.serviceConfigs) { + for (const ingressSpec of serviceConfig.spec.ingresses) { + const hostname = ingressSpec.hostname || provider.config.defaultHostname; + if (!hostname) { + throw new exceptions_1.ConfigurationError(`No hostname configured for one of the ingresses on service ${serviceConfig.name}. ` + + `Please configure a default hostname or specify a hostname for the ingress.`, { + serviceName: serviceConfig.name, + ingressSpec, + }); + } + // make sure the hostname is set + ingressSpec.hostname = hostname; + } + } + }); +} +exports.validate = validate; +function deleteService(params) { + return __awaiter(this, void 0, void 0, function* () { + const { ctx, logEntry, service } = params; + const namespace = yield namespace_1.getAppNamespace(ctx, ctx.provider); + const provider = ctx.provider; + yield deployment_1.deleteContainerService({ provider, namespace, serviceName: service.name, logEntry }); + return deployment_1.getContainerServiceStatus(params); + }); +} +exports.deleteService = deleteService; +function getServiceOutputs({ service }) { + return __awaiter(this, void 0, void 0, function* () { + return { + host: service.name, + }; + }); +} +exports.getServiceOutputs = getServiceOutputs; +function execInService(params) { + return __awaiter(this, void 0, void 0, function* () { + const { ctx, service, command } = params; + const api = new api_1.KubeApi(ctx.provider); + const status = yield deployment_1.getContainerServiceStatus(params); + const namespace = yield namespace_1.getAppNamespace(ctx, ctx.provider); + // TODO: this check should probably live outside of the plugin + if (!status.state || status.state !== "ready") { + throw new exceptions_1.DeploymentError(`Service ${service.name} is not running`, { + name: service.name, + state: status.state, + }); + } + // get a running pod + // NOTE: the awkward function signature called out here: https://github.com/kubernetes-client/javascript/issues/53 + const podsRes = yield api.core.listNamespacedPod(namespace, undefined, undefined, undefined, undefined, `service=${service.name}`); + const pod = podsRes.body.items[0]; + if (!pod) { + // This should not happen because of the prior status check, but checking to be sure + throw new exceptions_1.DeploymentError(`Could not find running pod for ${service.name}`, { + serviceName: service.name, + }); + } + // exec in the pod via kubectl + const kubecmd = ["exec", "-it", pod.metadata.name, "--", ...command]; + const res = yield kubectl_1.kubectl(api.context, namespace).tty(kubecmd, { + ignoreError: true, + silent: false, + timeout: 999999, + tty: true, + }); + return { code: res.code, output: res.output }; + }); +} +exports.execInService = execInService; +function runModule({ ctx, module, command, interactive, runtimeContext, silent, timeout }) { + return __awaiter(this, void 0, void 0, function* () { + const context = ctx.provider.config.context; + const namespace = yield namespace_1.getAppNamespace(ctx, ctx.provider); + const envArgs = Object.entries(runtimeContext.envVars).map(([k, v]) => `--env=${k}=${v}`); + const commandStr = command.join(" "); + const image = yield container_1.helpers.getLocalImageId(module); + const version = module.version; + const opts = [ + `--image=${image}`, + "--restart=Never", + "--command", + "--tty", + "--rm", + "-i", + "--quiet", + ]; + const kubecmd = [ + "run", `run-${module.name}-${Math.round(new Date().getTime())}`, + ...opts, + ...envArgs, + "--", + "/bin/sh", + "-c", + commandStr, + ]; + const startedAt = new Date(); + const res = yield kubectl_1.kubectl(context, namespace).tty(kubecmd, { + ignoreError: true, + silent: !interactive || silent, + timeout, + tty: interactive, + }); + return { + moduleName: module.name, + command, + version, + success: res.code === 0, + startedAt, + completedAt: new Date(), + output: res.output, + }; + }); +} +exports.runModule = runModule; +function runService({ ctx, service, interactive, runtimeContext, silent, timeout, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + return runModule({ + ctx, + module: service.module, + command: service.spec.command || [], + interactive, + runtimeContext, + silent, + timeout, + logEntry, + }); + }); +} +exports.runService = runService; +function testModule({ ctx, interactive, module, runtimeContext, silent, testConfig, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const testName = testConfig.name; + const command = testConfig.spec.command; + runtimeContext.envVars = Object.assign({}, runtimeContext.envVars, testConfig.spec.env); + const timeout = testConfig.timeout || constants_1.DEFAULT_TEST_TIMEOUT; + const result = yield runModule({ + ctx, + module, + command, + interactive, + runtimeContext, + silent, + timeout, + logEntry, + }); + const api = new api_1.KubeApi(ctx.provider); + // store test result + const testResult = Object.assign({}, result, { testName }); + const ns = yield namespace_1.getMetadataNamespace(ctx, ctx.provider); + const resultKey = getTestResultKey(module, testName, result.version); + const body = { + apiVersion: "v1", + kind: "ConfigMap", + metadata: { + name: resultKey, + annotations: { + "garden.io/generated": "true", + }, + }, + data: util_1.serializeValues(testResult), + }; + try { + yield api.core.createNamespacedConfigMap(ns, body); + } + catch (err) { + if (err.code === 409) { + yield api.core.patchNamespacedConfigMap(resultKey, ns, body); + } + else { + throw err; + } + } + return testResult; + }); +} +exports.testModule = testModule; +function getTestResult({ ctx, module, testName, version }) { + return __awaiter(this, void 0, void 0, function* () { + const api = new api_1.KubeApi(ctx.provider); + const ns = yield namespace_1.getMetadataNamespace(ctx, ctx.provider); + const resultKey = getTestResultKey(module, testName, version); + try { + const res = yield api.core.readNamespacedConfigMap(resultKey, ns); + return util_1.deserializeValues(res.body.data); + } + catch (err) { + if (err.code === 404) { + return null; + } + else { + throw err; + } + } + }); +} +exports.getTestResult = getTestResult; +function getServiceLogs({ ctx, service, stream, tail }) { + return __awaiter(this, void 0, void 0, function* () { + const context = ctx.provider.config.context; + const resourceType = service.spec.daemon ? "daemonset" : "deployment"; + const kubectlArgs = ["logs", `${resourceType}/${service.name}`, "--timestamps=true"]; + if (tail) { + kubectlArgs.push("--follow"); + } + const namespace = yield namespace_1.getAppNamespace(ctx, ctx.provider); + const proc = kubectl_1.kubectl(context, namespace).spawn(kubectlArgs); + let timestamp; + proc.stdout + .pipe(split()) + .on("data", (s) => { + if (!s) { + return; + } + const [timestampStr, msg] = util_1.splitFirst(s, " "); + try { + timestamp = moment(timestampStr).toDate(); + } + catch (_a) { } + void stream.write({ serviceName: service.name, timestamp, msg }); + }); + proc.stderr.pipe(process.stderr); + return new Promise((resolve, reject) => { + proc.on("error", reject); + proc.on("exit", () => { + resolve({}); + }); + }); + }); +} +exports.getServiceLogs = getServiceLogs; +function getTestResultKey(module, testName, version) { + return `test-result--${module.name}--${testName}--${version.versionString}`; +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/kubernetes/actions.ts"],"names":[],"mappings":"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","file":"plugins/kubernetes/actions.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as split from \"split\"\nimport moment = require(\"moment\")\n\nimport { DeploymentError, ConfigurationError } from \"../../exceptions\"\nimport { GetServiceLogsResult, RunResult, TestResult } from \"../../types/plugin/outputs\"\nimport {\n  ExecInServiceParams,\n  GetServiceLogsParams,\n  GetServiceOutputsParams,\n  GetTestResultParams,\n  RunModuleParams,\n  TestModuleParams,\n  DeleteServiceParams,\n  RunServiceParams,\n} from \"../../types/plugin/params\"\nimport { ModuleVersion } from \"../../vcs/base\"\nimport { ContainerModule, helpers, validateContainerModule } from \"../container\"\nimport { deserializeValues, serializeValues, splitFirst } from \"../../util/util\"\nimport { KubeApi } from \"./api\"\nimport { getAppNamespace, getMetadataNamespace } from \"./namespace\"\nimport { kubectl } from \"./kubectl\"\nimport { DEFAULT_TEST_TIMEOUT } from \"../../constants\"\nimport { KubernetesProvider } from \"./kubernetes\"\nimport { deleteContainerService, getContainerServiceStatus } from \"./deployment\"\nimport { ServiceStatus } from \"../../types/service\"\nimport { ValidateModuleParams } from \"../../types/plugin/params\"\n\nexport async function validate(params: ValidateModuleParams<ContainerModule>) {\n  const config = await validateContainerModule(params)\n\n  // validate ingress specs\n  const provider: KubernetesProvider = params.ctx.provider\n\n  for (const serviceConfig of config.serviceConfigs) {\n    for (const ingressSpec of serviceConfig.spec.ingresses) {\n      const hostname = ingressSpec.hostname || provider.config.defaultHostname\n\n      if (!hostname) {\n        throw new ConfigurationError(\n          `No hostname configured for one of the ingresses on service ${serviceConfig.name}. ` +\n          `Please configure a default hostname or specify a hostname for the ingress.`,\n          {\n            serviceName: serviceConfig.name,\n            ingressSpec,\n          },\n        )\n      }\n\n      // make sure the hostname is set\n      ingressSpec.hostname = hostname\n    }\n  }\n}\n\nexport async function deleteService(params: DeleteServiceParams): Promise<ServiceStatus> {\n  const { ctx, logEntry, service } = params\n  const namespace = await getAppNamespace(ctx, ctx.provider)\n  const provider = ctx.provider\n\n  await deleteContainerService(\n    { provider, namespace, serviceName: service.name, logEntry })\n\n  return getContainerServiceStatus(params)\n}\n\nexport async function getServiceOutputs({ service }: GetServiceOutputsParams<ContainerModule>) {\n  return {\n    host: service.name,\n  }\n}\n\nexport async function execInService(params: ExecInServiceParams<ContainerModule>) {\n  const { ctx, service, command } = params\n  const api = new KubeApi(ctx.provider)\n  const status = await getContainerServiceStatus(params)\n  const namespace = await getAppNamespace(ctx, ctx.provider)\n\n  // TODO: this check should probably live outside of the plugin\n  if (!status.state || status.state !== \"ready\") {\n    throw new DeploymentError(`Service ${service.name} is not running`, {\n      name: service.name,\n      state: status.state,\n    })\n  }\n\n  // get a running pod\n  // NOTE: the awkward function signature called out here: https://github.com/kubernetes-client/javascript/issues/53\n  const podsRes = await api.core.listNamespacedPod(\n    namespace,\n    undefined,\n    undefined,\n    undefined,\n    undefined,\n    `service=${service.name}`,\n  )\n  const pod = podsRes.body.items[0]\n\n  if (!pod) {\n    // This should not happen because of the prior status check, but checking to be sure\n    throw new DeploymentError(`Could not find running pod for ${service.name}`, {\n      serviceName: service.name,\n    })\n  }\n\n  // exec in the pod via kubectl\n  const kubecmd = [\"exec\", \"-it\", pod.metadata.name, \"--\", ...command]\n  const res = await kubectl(api.context, namespace).tty(kubecmd, {\n    ignoreError: true,\n    silent: false,\n    timeout: 999999,\n    tty: true,\n  })\n\n  return { code: res.code, output: res.output }\n}\n\nexport async function runModule(\n  { ctx, module, command, interactive, runtimeContext, silent, timeout }: RunModuleParams<ContainerModule>,\n): Promise<RunResult> {\n  const context = ctx.provider.config.context\n  const namespace = await getAppNamespace(ctx, ctx.provider)\n\n  const envArgs = Object.entries(runtimeContext.envVars).map(([k, v]) => `--env=${k}=${v}`)\n\n  const commandStr = command.join(\" \")\n  const image = await helpers.getLocalImageId(module)\n  const version = module.version\n\n  const opts = [\n    `--image=${image}`,\n    \"--restart=Never\",\n    \"--command\",\n    \"--tty\",\n    \"--rm\",\n    \"-i\",\n    \"--quiet\",\n  ]\n\n  const kubecmd = [\n    \"run\", `run-${module.name}-${Math.round(new Date().getTime())}`,\n    ...opts,\n    ...envArgs,\n    \"--\",\n    \"/bin/sh\",\n    \"-c\",\n    commandStr,\n  ]\n\n  const startedAt = new Date()\n\n  const res = await kubectl(context, namespace).tty(kubecmd, {\n    ignoreError: true,\n    silent: !interactive || silent, // shouldn't be silent in interactive mode\n    timeout,\n    tty: interactive,\n  })\n\n  return {\n    moduleName: module.name,\n    command,\n    version,\n    success: res.code === 0,\n    startedAt,\n    completedAt: new Date(),\n    output: res.output,\n  }\n}\n\nexport async function runService(\n  { ctx, service, interactive, runtimeContext, silent, timeout, logEntry }:\n    RunServiceParams<ContainerModule>,\n) {\n  return runModule({\n    ctx,\n    module: service.module,\n    command: service.spec.command || [],\n    interactive,\n    runtimeContext,\n    silent,\n    timeout,\n    logEntry,\n  })\n}\n\nexport async function testModule(\n  { ctx, interactive, module, runtimeContext, silent, testConfig, logEntry }:\n    TestModuleParams<ContainerModule>,\n): Promise<TestResult> {\n  const testName = testConfig.name\n  const command = testConfig.spec.command\n  runtimeContext.envVars = { ...runtimeContext.envVars, ...testConfig.spec.env }\n  const timeout = testConfig.timeout || DEFAULT_TEST_TIMEOUT\n\n  const result = await runModule({\n    ctx,\n    module,\n    command,\n    interactive,\n    runtimeContext,\n    silent,\n    timeout,\n    logEntry,\n  })\n\n  const api = new KubeApi(ctx.provider)\n\n  // store test result\n  const testResult: TestResult = {\n    ...result,\n    testName,\n  }\n\n  const ns = await getMetadataNamespace(ctx, ctx.provider)\n  const resultKey = getTestResultKey(module, testName, result.version)\n  const body = {\n    apiVersion: \"v1\",\n    kind: \"ConfigMap\",\n    metadata: {\n      name: resultKey,\n      annotations: {\n        \"garden.io/generated\": \"true\",\n      },\n    },\n    data: serializeValues(testResult),\n  }\n\n  try {\n    await api.core.createNamespacedConfigMap(ns, <any>body)\n  } catch (err) {\n    if (err.code === 409) {\n      await api.core.patchNamespacedConfigMap(resultKey, ns, body)\n    } else {\n      throw err\n    }\n  }\n\n  return testResult\n}\n\nexport async function getTestResult(\n  { ctx, module, testName, version }: GetTestResultParams<ContainerModule>,\n) {\n  const api = new KubeApi(ctx.provider)\n  const ns = await getMetadataNamespace(ctx, ctx.provider)\n  const resultKey = getTestResultKey(module, testName, version)\n\n  try {\n    const res = await api.core.readNamespacedConfigMap(resultKey, ns)\n    return <TestResult>deserializeValues(res.body.data)\n  } catch (err) {\n    if (err.code === 404) {\n      return null\n    } else {\n      throw err\n    }\n  }\n}\n\nexport async function getServiceLogs(\n  { ctx, service, stream, tail }: GetServiceLogsParams<ContainerModule>,\n) {\n  const context = ctx.provider.config.context\n  const resourceType = service.spec.daemon ? \"daemonset\" : \"deployment\"\n\n  const kubectlArgs = [\"logs\", `${resourceType}/${service.name}`, \"--timestamps=true\"]\n\n  if (tail) {\n    kubectlArgs.push(\"--follow\")\n  }\n\n  const namespace = await getAppNamespace(ctx, ctx.provider)\n  const proc = kubectl(context, namespace).spawn(kubectlArgs)\n  let timestamp: Date\n\n  proc.stdout\n    .pipe(split())\n    .on(\"data\", (s) => {\n      if (!s) {\n        return\n      }\n      const [timestampStr, msg] = splitFirst(s, \" \")\n      try {\n        timestamp = moment(timestampStr).toDate()\n      } catch { }\n      void stream.write({ serviceName: service.name, timestamp, msg })\n    })\n\n  proc.stderr.pipe(process.stderr)\n\n  return new Promise<GetServiceLogsResult>((resolve, reject) => {\n    proc.on(\"error\", reject)\n\n    proc.on(\"exit\", () => {\n      resolve({})\n    })\n  })\n}\n\nfunction getTestResultKey(module: ContainerModule, testName: string, version: ModuleVersion) {\n  return `test-result--${module.name}--${testName}--${version.versionString}`\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/api.d.ts b/garden-service/build/plugins/kubernetes/api.d.ts new file mode 100644 index 00000000000..8a4de89952d --- /dev/null +++ b/garden-service/build/plugins/kubernetes/api.d.ts @@ -0,0 +1,100 @@ +/// +import { Core_v1Api, Extensions_v1beta1Api, RbacAuthorization_v1Api, Apps_v1Api, Apiextensions_v1beta1Api, V1Secret, Policy_v1beta1Api } from "@kubernetes/client-node"; +import { GardenBaseError } from "../../exceptions"; +import { KubernetesObject } from "./helm"; +import { KubernetesProvider } from "./kubernetes"; +declare const crudMap: { + Secret: { + type: typeof V1Secret; + group: string; + read: string; + create: string; + patch: string; + delete: string; + }; +}; +declare type CrudMapType = typeof crudMap; +export declare class KubernetesError extends GardenBaseError { + type: string; + code?: number; + response?: any; +} +export declare class KubeApi { + provider: KubernetesProvider; + context: string; + apiExtensions: Apiextensions_v1beta1Api; + apps: Apps_v1Api; + core: Core_v1Api; + extensions: Extensions_v1beta1Api; + policy: Policy_v1beta1Api; + rbac: RbacAuthorization_v1Api; + constructor(provider: KubernetesProvider); + readBySpec(namespace: string, spec: KubernetesObject): Promise<{ + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1beta1CustomResourceDefinition; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1StatefulSet; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1ConfigMap; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1Endpoints; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1LimitRange; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1PersistentVolumeClaim; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1Pod; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1PodTemplate; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1ReplicationController; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1ResourceQuota; + } | { + response: import("http").ClientResponse; + body: V1Secret; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1Service; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1ServiceAccount; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1beta1DaemonSet; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").ExtensionsV1beta1Deployment; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1beta1Ingress; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1beta1ReplicaSet; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1beta1PodDisruptionBudget; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1ClusterRoleBinding; + } | { + response: import("http").ClientResponse; + body: import("@kubernetes/client-node/dist/api").V1Role; + }>; + upsert(kind: K, namespace: string, obj: KubernetesObject): Promise; + /** + * Wrapping the API objects to deal with bugs. + */ + private proxyApi; +} +export {}; +//# sourceMappingURL=api.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/api.js b/garden-service/build/plugins/kubernetes/api.js new file mode 100644 index 00000000000..de40a4cc40d --- /dev/null +++ b/garden-service/build/plugins/kubernetes/api.js @@ -0,0 +1,212 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const client_node_1 = require("@kubernetes/client-node"); +const path_1 = require("path"); +const fs_1 = require("fs"); +const js_yaml_1 = require("js-yaml"); +const lodash_1 = require("lodash"); +const exceptions_1 = require("../../exceptions"); +const os_1 = require("os"); +let kubeConfigStr; +let kubeConfig; +const configs = {}; +const apiTypes = { + apiExtensions: client_node_1.Apiextensions_v1beta1Api, + apps: client_node_1.Apps_v1Api, + core: client_node_1.Core_v1Api, + extensions: client_node_1.Extensions_v1beta1Api, + policy: client_node_1.Policy_v1beta1Api, + rbac: client_node_1.RbacAuthorization_v1Api, +}; +const crudMap = { + Secret: { + type: client_node_1.V1Secret, + group: "core", + read: "readNamespacedSecret", + create: "createNamespacedSecret", + patch: "patchNamespacedSecret", + delete: "deleteNamespacedSecret", + }, +}; +class KubernetesError extends exceptions_1.GardenBaseError { + constructor() { + super(...arguments); + this.type = "kubernetes"; + } +} +exports.KubernetesError = KubernetesError; +class KubeApi { + constructor(provider) { + this.provider = provider; + this.context = provider.config.context; + const config = getSecret(this.context); + for (const [name, cls] of Object.entries(apiTypes)) { + const api = new cls(config.getCurrentCluster().server); + this[name] = this.proxyApi(api, config); + } + } + readBySpec(namespace, spec) { + return __awaiter(this, void 0, void 0, function* () { + // this is just awful, sorry. any better ideas? - JE + const name = spec.metadata.name; + switch (spec.kind) { + case "ConfigMap": + return this.core.readNamespacedConfigMap(name, namespace); + case "Endpoints": + return this.core.readNamespacedEndpoints(name, namespace); + case "LimitRange": + return this.core.readNamespacedLimitRange(name, namespace); + case "PersistentVolumeClaim": + return this.core.readNamespacedPersistentVolumeClaim(name, namespace); + case "Pod": + return this.core.readNamespacedPod(name, namespace); + case "PodTemplate": + return this.core.readNamespacedPodTemplate(name, namespace); + case "ReplicationController": + return this.core.readNamespacedReplicationController(name, namespace); + case "ResourceQuota": + return this.core.readNamespacedResourceQuota(name, namespace); + case "Secret": + return this.core.readNamespacedSecret(name, namespace); + case "Service": + return this.core.readNamespacedService(name, namespace); + case "ServiceAccount": + return this.core.readNamespacedServiceAccount(name, namespace); + case "DaemonSet": + return this.extensions.readNamespacedDaemonSet(name, namespace); + case "Deployment": + return this.extensions.readNamespacedDeployment(name, namespace); + case "Ingress": + return this.extensions.readNamespacedIngress(name, namespace); + case "ReplicaSet": + return this.extensions.readNamespacedReplicaSet(name, namespace); + case "StatefulSet": + return this.apps.readNamespacedStatefulSet(name, namespace); + case "ClusterRole": + return this.rbac.readClusterRole(name); + case "ClusterRoleBinding": + return this.rbac.readClusterRoleBinding(name); + case "Role": + return this.rbac.readNamespacedRole(name, namespace); + case "RoleBinding": + return this.rbac.readNamespacedRoleBinding(name, namespace); + case "CustomResourceDefinition": + return this.apiExtensions.readCustomResourceDefinition(name); + case "PodDisruptionBudget": + return this.policy.readNamespacedPodDisruptionBudget(name, namespace); + default: + throw new exceptions_1.ConfigurationError(`Unsupported Kubernetes spec kind: ${spec.kind}`, { + spec, + }); + } + }); + } + upsert(kind, namespace, obj) { + return __awaiter(this, void 0, void 0, function* () { + const api = this[crudMap[kind].group]; + try { + const res = yield api[crudMap[kind].read](obj.metadata.name, namespace); + return res.body; + } + catch (err) { + if (err.code === 404) { + try { + yield api[crudMap[kind].create](namespace, obj); + } + catch (err) { + if (err.code === 409) { + yield api[crudMap[kind].patch](name, namespace, obj); + } + else { + throw err; + } + } + } + else { + throw err; + } + } + return obj; + }); + } + /** + * Wrapping the API objects to deal with bugs. + */ + proxyApi(api, config) { + api.setDefaultAuthentication(config); + return new Proxy(api, { + get: (target, name, receiver) => { + if (!(name in Object.getPrototypeOf(target))) { // assume methods live on the prototype + return Reflect.get(target, name, receiver); + } + return function (...args) { + const defaultHeaders = target["defaultHeaders"]; + if (name.startsWith("patch")) { + // patch the patch bug... (https://github.com/kubernetes-client/javascript/issues/19) + target["defaultHeaders"] = Object.assign({}, defaultHeaders, { "content-type": "application/strategic-merge-patch+json" }); + } + const output = target[name](...args); + target["defaultHeaders"] = defaultHeaders; + if (typeof output.then === "function") { + // the API errors are not properly formed Error objects + return output.catch(wrapError); + } + else { + return output; + } + }; + }, + }); + } +} +exports.KubeApi = KubeApi; +function getSecret(context) { + if (!kubeConfigStr) { + const kubeConfigPath = process.env.KUBECONFIG || path_1.join(os_1.homedir(), ".kube", "config"); + kubeConfigStr = fs_1.readFileSync(kubeConfigPath).toString(); + kubeConfig = js_yaml_1.safeLoad(kubeConfigStr); + } + if (!configs[context]) { + const kc = new client_node_1.KubeConfig(); + kc.loadFromString(kubeConfigStr); + kc.setCurrentContext(context); + // FIXME: need to patch a bug in the library here (https://github.com/kubernetes-client/javascript/pull/54) + for (const [a, b] of lodash_1.zip(kubeConfig["clusters"] || [], kc.clusters)) { + if (a && a["cluster"]["insecure-skip-tls-verify"] === true) { + b.skipTLSVerify = true; + } + } + configs[context] = kc; + } + return configs[context]; +} +function wrapError(err) { + if (!err.message) { + const wrapped = new KubernetesError(`Got error from Kubernetes API - ${err.body.message}`, { + body: err.body, + request: lodash_1.omitBy(err.response.request, (v, k) => lodash_1.isObject(v) || k[0] === "_"), + }); + wrapped.code = err.response.statusCode; + throw wrapped; + } + else { + throw err; + } +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/kubernetes/api.ts"],"names":[],"mappings":"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","file":"plugins/kubernetes/api.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport {\n  KubeConfig,\n  Core_v1Api,\n  Extensions_v1beta1Api,\n  RbacAuthorization_v1Api,\n  Apps_v1Api,\n  Apiextensions_v1beta1Api,\n  V1Secret,\n  Policy_v1beta1Api,\n} from \"@kubernetes/client-node\"\nimport { join } from \"path\"\nimport { readFileSync } from \"fs\"\nimport { safeLoad } from \"js-yaml\"\nimport { zip, omitBy, isObject } from \"lodash\"\nimport { GardenBaseError, ConfigurationError } from \"../../exceptions\"\nimport { KubernetesObject } from \"./helm\"\nimport { homedir } from \"os\"\nimport { KubernetesProvider } from \"./kubernetes\"\n\nlet kubeConfigStr: string\nlet kubeConfig: any\n\nconst configs: { [context: string]: KubeConfig } = {}\n\n// NOTE: be warned, the API of the client library is very likely to change\n\ntype K8sApi = Core_v1Api\n  | Extensions_v1beta1Api\n  | RbacAuthorization_v1Api\n  | Apps_v1Api\n  | Apiextensions_v1beta1Api\n  | Policy_v1beta1Api\ntype K8sApiConstructor<T extends K8sApi> = new (basePath?: string) => T\n\nconst apiTypes: { [key: string]: K8sApiConstructor<any> } = {\n  apiExtensions: Apiextensions_v1beta1Api,\n  apps: Apps_v1Api,\n  core: Core_v1Api,\n  extensions: Extensions_v1beta1Api,\n  policy: Policy_v1beta1Api,\n  rbac: RbacAuthorization_v1Api,\n}\n\nconst crudMap = {\n  Secret: {\n    type: V1Secret,\n    group: \"core\",\n    read: \"readNamespacedSecret\",\n    create: \"createNamespacedSecret\",\n    patch: \"patchNamespacedSecret\",\n    delete: \"deleteNamespacedSecret\",\n  },\n}\n\ntype CrudMapType = typeof crudMap\n\nexport class KubernetesError extends GardenBaseError {\n  type = \"kubernetes\"\n\n  code?: number\n  response?: any\n}\n\nexport class KubeApi {\n  public context: string\n\n  public apiExtensions: Apiextensions_v1beta1Api\n  public apps: Apps_v1Api\n  public core: Core_v1Api\n  public extensions: Extensions_v1beta1Api\n  public policy: Policy_v1beta1Api\n  public rbac: RbacAuthorization_v1Api\n\n  constructor(public provider: KubernetesProvider) {\n    this.context = provider.config.context\n    const config = getSecret(this.context)\n\n    for (const [name, cls] of Object.entries(apiTypes)) {\n      const api = new cls(config.getCurrentCluster().server)\n      this[name] = this.proxyApi(api, config)\n    }\n  }\n\n  async readBySpec(namespace: string, spec: KubernetesObject) {\n    // this is just awful, sorry. any better ideas? - JE\n    const name = spec.metadata.name\n\n    switch (spec.kind) {\n      case \"ConfigMap\":\n        return this.core.readNamespacedConfigMap(name, namespace)\n      case \"Endpoints\":\n        return this.core.readNamespacedEndpoints(name, namespace)\n      case \"LimitRange\":\n        return this.core.readNamespacedLimitRange(name, namespace)\n      case \"PersistentVolumeClaim\":\n        return this.core.readNamespacedPersistentVolumeClaim(name, namespace)\n      case \"Pod\":\n        return this.core.readNamespacedPod(name, namespace)\n      case \"PodTemplate\":\n        return this.core.readNamespacedPodTemplate(name, namespace)\n      case \"ReplicationController\":\n        return this.core.readNamespacedReplicationController(name, namespace)\n      case \"ResourceQuota\":\n        return this.core.readNamespacedResourceQuota(name, namespace)\n      case \"Secret\":\n        return this.core.readNamespacedSecret(name, namespace)\n      case \"Service\":\n        return this.core.readNamespacedService(name, namespace)\n      case \"ServiceAccount\":\n        return this.core.readNamespacedServiceAccount(name, namespace)\n      case \"DaemonSet\":\n        return this.extensions.readNamespacedDaemonSet(name, namespace)\n      case \"Deployment\":\n        return this.extensions.readNamespacedDeployment(name, namespace)\n      case \"Ingress\":\n        return this.extensions.readNamespacedIngress(name, namespace)\n      case \"ReplicaSet\":\n        return this.extensions.readNamespacedReplicaSet(name, namespace)\n      case \"StatefulSet\":\n        return this.apps.readNamespacedStatefulSet(name, namespace)\n      case \"ClusterRole\":\n        return this.rbac.readClusterRole(name)\n      case \"ClusterRoleBinding\":\n        return this.rbac.readClusterRoleBinding(name)\n      case \"Role\":\n        return this.rbac.readNamespacedRole(name, namespace)\n      case \"RoleBinding\":\n        return this.rbac.readNamespacedRoleBinding(name, namespace)\n      case \"CustomResourceDefinition\":\n        return this.apiExtensions.readCustomResourceDefinition(name)\n      case \"PodDisruptionBudget\":\n        return this.policy.readNamespacedPodDisruptionBudget(name, namespace)\n      default:\n        throw new ConfigurationError(`Unsupported Kubernetes spec kind: ${spec.kind}`, {\n          spec,\n        })\n    }\n  }\n\n  async upsert<K extends keyof CrudMapType>(\n    kind: K, namespace: string, obj: KubernetesObject,\n  ): Promise<KubernetesObject> {\n    const api = this[crudMap[kind].group]\n\n    try {\n      const res = await api[crudMap[kind].read](obj.metadata.name, namespace)\n      return res.body\n    } catch (err) {\n      if (err.code === 404) {\n        try {\n          await api[crudMap[kind].create](namespace, <any>obj)\n        } catch (err) {\n          if (err.code === 409) {\n            await api[crudMap[kind].patch](name, namespace, obj)\n          } else {\n            throw err\n          }\n        }\n      } else {\n        throw err\n      }\n    }\n\n    return obj\n  }\n\n  /**\n   * Wrapping the API objects to deal with bugs.\n   */\n  private proxyApi<T extends K8sApi>(api: T, config): T {\n    api.setDefaultAuthentication(config)\n\n    return new Proxy(api, {\n      get: (target: T, name: string, receiver) => {\n        if (!(name in Object.getPrototypeOf(target))) { // assume methods live on the prototype\n          return Reflect.get(target, name, receiver)\n        }\n\n        return function(...args) {\n          const defaultHeaders = target[\"defaultHeaders\"]\n\n          if (name.startsWith(\"patch\")) {\n            // patch the patch bug... (https://github.com/kubernetes-client/javascript/issues/19)\n            target[\"defaultHeaders\"] = { ...defaultHeaders, \"content-type\": \"application/strategic-merge-patch+json\" }\n          }\n\n          const output = target[name](...args)\n          target[\"defaultHeaders\"] = defaultHeaders\n\n          if (typeof output.then === \"function\") {\n            // the API errors are not properly formed Error objects\n            return output.catch(wrapError)\n          } else {\n            return output\n          }\n        }\n      },\n    })\n  }\n}\n\nfunction getSecret(context: string): KubeConfig {\n  if (!kubeConfigStr) {\n    const kubeConfigPath = process.env.KUBECONFIG || join(homedir(), \".kube\", \"config\")\n    kubeConfigStr = readFileSync(kubeConfigPath).toString()\n    kubeConfig = safeLoad(kubeConfigStr)\n  }\n\n  if (!configs[context]) {\n    const kc = new KubeConfig()\n\n    kc.loadFromString(kubeConfigStr)\n    kc.setCurrentContext(context)\n\n    // FIXME: need to patch a bug in the library here (https://github.com/kubernetes-client/javascript/pull/54)\n    for (const [a, b] of zip(kubeConfig[\"clusters\"] || [], kc.clusters)) {\n      if (a && a[\"cluster\"][\"insecure-skip-tls-verify\"] === true) {\n        (<any>b).skipTLSVerify = true\n      }\n    }\n\n    configs[context] = kc\n  }\n\n  return configs[context]\n}\n\nfunction wrapError(err) {\n  if (!err.message) {\n    const wrapped = new KubernetesError(`Got error from Kubernetes API - ${err.body.message}`, {\n      body: err.body,\n      request: omitBy(err.response.request, (v, k) => isObject(v) || k[0] === \"_\"),\n    })\n    wrapped.code = err.response.statusCode\n    throw wrapped\n  } else {\n    throw err\n  }\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/deployment.d.ts b/garden-service/build/plugins/kubernetes/deployment.d.ts new file mode 100644 index 00000000000..94d4fbcd67a --- /dev/null +++ b/garden-service/build/plugins/kubernetes/deployment.d.ts @@ -0,0 +1,34 @@ +import { DeployServiceParams, GetServiceStatusParams, PushModuleParams } from "../../types/plugin/params"; +import { ContainerModule, ContainerService } from "../container"; +import { RuntimeContext, ServiceStatus } from "../../types/service"; +import { KubernetesObject } from "./helm"; +import { PluginContext } from "../../plugin-context"; +import { KubernetesProvider } from "./kubernetes"; +export declare const DEFAULT_CPU_REQUEST = "10m"; +export declare const DEFAULT_CPU_LIMIT = "500m"; +export declare const DEFAULT_MEMORY_REQUEST = "128Mi"; +export declare const DEFAULT_MEMORY_LIMIT = "512Mi"; +export declare function getContainerServiceStatus({ ctx, module, service, runtimeContext }: GetServiceStatusParams): Promise; +export declare function deployContainerService(params: DeployServiceParams): Promise; +export declare function createContainerObjects(ctx: PluginContext, service: ContainerService, runtimeContext: RuntimeContext): Promise; +export declare function createDeployment(provider: KubernetesProvider, service: ContainerService, runtimeContext: RuntimeContext, namespace: string): Promise; +export declare function deleteContainerService({ namespace, provider, serviceName, logEntry }: { + namespace: any; + provider: any; + serviceName: any; + logEntry: any; +}): Promise; +export declare function deleteContainerDeployment({ namespace, provider, serviceName, logEntry }: { + namespace: any; + provider: any; + serviceName: any; + logEntry: any; +}): Promise; +export declare function pushModule({ ctx, module, logEntry }: PushModuleParams): Promise<{ + pushed: boolean; + message?: undefined; +} | { + pushed: boolean; + message: string; +}>; +//# sourceMappingURL=deployment.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/deployment.js b/garden-service/build/plugins/kubernetes/deployment.js new file mode 100644 index 00000000000..76dc8727fb5 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/deployment.js @@ -0,0 +1,341 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const container_1 = require("../container"); +const lodash_1 = require("lodash"); +const ingress_1 = require("./ingress"); +const service_1 = require("./service"); +const status_1 = require("./status"); +const kubectl_1 = require("./kubectl"); +const namespace_1 = require("./namespace"); +const constants_1 = require("../../constants"); +const api_1 = require("./api"); +exports.DEFAULT_CPU_REQUEST = "10m"; +exports.DEFAULT_CPU_LIMIT = "500m"; +exports.DEFAULT_MEMORY_REQUEST = "128Mi"; +exports.DEFAULT_MEMORY_LIMIT = "512Mi"; +function getContainerServiceStatus({ ctx, module, service, runtimeContext }) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: hash and compare all the configuration files (otherwise internal changes don't get deployed) + const version = module.version; + const objects = yield createContainerObjects(ctx, service, runtimeContext); + const matched = yield status_1.compareDeployedObjects(ctx, objects); + const api = new api_1.KubeApi(ctx.provider); + const ingresses = yield ingress_1.getIngresses(service, api); + return { + ingresses, + state: matched ? "ready" : "outdated", + version: matched ? version.versionString : undefined, + }; + }); +} +exports.getContainerServiceStatus = getContainerServiceStatus; +function deployContainerService(params) { + return __awaiter(this, void 0, void 0, function* () { + const { ctx, service, runtimeContext, force, logEntry } = params; + const provider = ctx.provider; + const namespace = yield namespace_1.getAppNamespace(ctx, provider); + const objects = yield createContainerObjects(ctx, service, runtimeContext); + // TODO: use Helm instead of kubectl apply + const pruneSelector = "service=" + service.name; + yield kubectl_1.applyMany(provider.config.context, objects, { force, namespace, pruneSelector }); + yield status_1.waitForObjects({ ctx, provider, service, objects, logEntry }); + return getContainerServiceStatus(params); + }); +} +exports.deployContainerService = deployContainerService; +function createContainerObjects(ctx, service, runtimeContext) { + return __awaiter(this, void 0, void 0, function* () { + const version = service.module.version; + const provider = ctx.provider; + const namespace = yield namespace_1.getAppNamespace(ctx, provider); + const deployment = yield createDeployment(provider, service, runtimeContext, namespace); + const kubeservices = yield service_1.createServices(service, namespace); + const api = new api_1.KubeApi(provider); + const ingresses = yield ingress_1.createIngresses(api, namespace, service); + const objects = [deployment, ...kubeservices, ...ingresses]; + return objects.map(obj => { + lodash_1.set(obj, ["metadata", "annotations", "garden.io/generated"], "true"); + lodash_1.set(obj, ["metadata", "annotations", constants_1.GARDEN_ANNOTATION_KEYS_VERSION], version.versionString); + lodash_1.set(obj, ["metadata", "labels", "module"], service.module.name); + lodash_1.set(obj, ["metadata", "labels", "service"], service.name); + return obj; + }); + }); +} +exports.createContainerObjects = createContainerObjects; +function createDeployment(provider, service, runtimeContext, namespace) { + return __awaiter(this, void 0, void 0, function* () { + const spec = service.spec; + // TODO: support specifying replica count + const configuredReplicas = 1; // service.spec.count[env.name] || 1 + const labels = { + module: service.module.name, + service: service.name, + }; + // TODO: moar type-safety + const deployment = { + kind: "Deployment", + apiVersion: "extensions/v1beta1", + metadata: { + name: service.name, + annotations: { + // we can use this to avoid overriding the replica count if it has been manually scaled + "garden.io/configured.replicas": configuredReplicas.toString(), + }, + namespace, + labels, + }, + spec: { + selector: { + matchLabels: { + service: service.name, + }, + }, + template: { + metadata: { + labels, + }, + spec: { + // TODO: set this for non-system pods + // automountServiceAccountToken: false, // this prevents the pod from accessing the kubernetes API + containers: [], + // TODO: make restartPolicy configurable + restartPolicy: "Always", + terminationGracePeriodSeconds: 10, + dnsPolicy: "ClusterFirst", + }, + }, + }, + }; + const envVars = Object.assign({}, runtimeContext.envVars, service.spec.env); + const env = lodash_1.toPairs(envVars).map(([name, value]) => ({ name, value: value + "" })); + // expose some metadata to the container + env.push({ + name: "POD_NAME", + valueFrom: { fieldRef: { fieldPath: "metadata.name" } }, + }); + env.push({ + name: "POD_NAMESPACE", + valueFrom: { fieldRef: { fieldPath: "metadata.namespace" } }, + }); + env.push({ + name: "POD_IP", + valueFrom: { fieldRef: { fieldPath: "status.podIP" } }, + }); + const registryConfig = provider.name === "local-kubernetes" ? undefined : provider.config.deploymentRegistry; + const image = yield container_1.helpers.getDeploymentImageId(service.module, registryConfig); + const container = { + name: service.name, + image, + env, + ports: [], + // TODO: make these configurable + resources: { + requests: { + cpu: exports.DEFAULT_CPU_REQUEST, + memory: exports.DEFAULT_MEMORY_REQUEST, + }, + limits: { + cpu: exports.DEFAULT_CPU_LIMIT, + memory: exports.DEFAULT_MEMORY_LIMIT, + }, + }, + imagePullPolicy: "IfNotPresent", + }; + if (service.spec.command && service.spec.command.length > 0) { + container.args = service.spec.command; + } + // if (config.entrypoint) { + // container.command = [config.entrypoint] + // } + if (spec.healthCheck) { + container.readinessProbe = { + initialDelaySeconds: 10, + periodSeconds: 5, + timeoutSeconds: 3, + successThreshold: 2, + failureThreshold: 5, + }; + container.livenessProbe = { + initialDelaySeconds: 15, + periodSeconds: 5, + timeoutSeconds: 3, + successThreshold: 1, + failureThreshold: 3, + }; + const portsByName = lodash_1.keyBy(spec.ports, "name"); + if (spec.healthCheck.httpGet) { + const httpGet = lodash_1.extend({}, spec.healthCheck.httpGet); + httpGet.port = portsByName[httpGet.port].containerPort; + container.readinessProbe.httpGet = httpGet; + container.livenessProbe.httpGet = httpGet; + } + else if (spec.healthCheck.command) { + container.readinessProbe.exec = { command: spec.healthCheck.command.map(s => s.toString()) }; + container.livenessProbe.exec = container.readinessProbe.exec; + } + else if (spec.healthCheck.tcpPort) { + container.readinessProbe.tcpSocket = { + port: portsByName[spec.healthCheck.tcpPort].containerPort, + }; + container.livenessProbe.tcpSocket = container.readinessProbe.tcpSocket; + } + else { + throw new Error("Must specify type of health check when configuring health check."); + } + } + // if (service.privileged) { + // container.securityContext = { + // privileged: true, + // } + // } + if (spec.volumes && spec.volumes.length) { + const volumes = []; + const volumeMounts = []; + for (const volume of spec.volumes) { + const volumeName = volume.name; + const volumeType = !!volume.hostPath ? "hostPath" : "emptyDir"; + if (!volumeName) { + throw new Error("Must specify volume name"); + } + if (volumeType === "emptyDir") { + volumes.push({ + name: volumeName, + emptyDir: {}, + }); + volumeMounts.push({ + name: volumeName, + mountPath: volume.containerPath, + }); + } + else if (volumeType === "hostPath") { + volumes.push({ + name: volumeName, + hostPath: { + path: volume.hostPath, + }, + }); + volumeMounts.push({ + name: volumeName, + mountPath: volume.containerPath || volume.hostPath, + }); + } + else { + throw new Error("Unsupported volume type: " + volumeType); + } + } + deployment.spec.template.spec.volumes = volumes; + container.volumeMounts = volumeMounts; + } + const ports = spec.ports; + for (const port of ports) { + container.ports.push({ + protocol: port.protocol, + containerPort: port.containerPort, + }); + } + if (spec.daemon) { + // this runs a pod on every node + deployment.kind = "DaemonSet"; + deployment.spec.updateStrategy = { + type: "RollingUpdate", + }; + for (const port of ports.filter(p => p.hostPort)) { + // For daemons we can expose host ports directly on the Pod, as opposed to only via the Service resource. + // This allows us to choose any port. + // TODO: validate that conflicting ports are not defined. + container.ports.push({ + protocol: port.protocol, + containerPort: port.containerPort, + hostPort: port.hostPort, + }); + } + } + else { + deployment.spec.replicas = configuredReplicas; + deployment.spec.strategy = { + type: "RollingUpdate", + rollingUpdate: { + maxUnavailable: "34%", + maxSurge: "34%", + }, + }; + deployment.spec.revisionHistoryLimit = 3; + } + if (provider.config.imagePullSecrets.length > 0) { + // add any configured imagePullSecrets + deployment.spec.template.spec.imagePullSecrets = provider.config.imagePullSecrets.map(s => ({ name: s.name })); + } + deployment.spec.template.spec.containers = [container]; + return deployment; + }); +} +exports.createDeployment = createDeployment; +function deleteContainerService({ namespace, provider, serviceName, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const context = provider.config.context; + yield deleteContainerDeployment({ namespace, provider, serviceName, logEntry }); + yield kubectl_1.deleteObjectsByLabel({ + context, + namespace, + labelKey: "service", + labelValue: serviceName, + objectTypes: ["deployment", "service", "ingress"], + includeUninitialized: false, + }); + }); +} +exports.deleteContainerService = deleteContainerService; +function deleteContainerDeployment({ namespace, provider, serviceName, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + let found = true; + const api = new api_1.KubeApi(provider); + try { + yield api.extensions.deleteNamespacedDeployment(serviceName, namespace, {}); + } + catch (err) { + if (err.code === 404) { + found = false; + } + else { + throw err; + } + } + if (logEntry) { + found ? logEntry.setSuccess("Service deleted") : logEntry.setWarn("Service not deployed"); + } + }); +} +exports.deleteContainerDeployment = deleteContainerDeployment; +function pushModule({ ctx, module, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + if (!(yield container_1.helpers.hasDockerfile(module))) { + logEntry && logEntry.setState({ msg: `Nothing to push` }); + return { pushed: false }; + } + const localId = yield container_1.helpers.getLocalImageId(module); + const remoteId = yield container_1.helpers.getDeploymentImageId(module, ctx.provider.config.deploymentRegistry); + logEntry && logEntry.setState({ msg: `Pushing image ${remoteId}...` }); + yield container_1.helpers.dockerCli(module, `tag ${localId} ${remoteId}`); + yield container_1.helpers.dockerCli(module, `push ${remoteId}`); + return { pushed: true, message: `Pushed ${localId}` }; + }); +} +exports.pushModule = pushModule; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/kubernetes/deployment.ts"],"names":[],"mappings":"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","file":"plugins/kubernetes/deployment.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { DeployServiceParams, GetServiceStatusParams, PushModuleParams } from \"../../types/plugin/params\"\nimport { helpers, ContainerModule, ContainerService } from \"../container\"\nimport { toPairs, extend, keyBy, set } from \"lodash\"\nimport { RuntimeContext, ServiceStatus } from \"../../types/service\"\nimport { createIngresses, getIngresses } from \"./ingress\"\nimport { createServices } from \"./service\"\nimport { waitForObjects, compareDeployedObjects } from \"./status\"\nimport { applyMany, deleteObjectsByLabel } from \"./kubectl\"\nimport { getAppNamespace } from \"./namespace\"\nimport { KubernetesObject } from \"./helm\"\nimport { PluginContext } from \"../../plugin-context\"\nimport { GARDEN_ANNOTATION_KEYS_VERSION } from \"../../constants\"\nimport { KubeApi } from \"./api\"\nimport { KubernetesProvider } from \"./kubernetes\"\n\nexport const DEFAULT_CPU_REQUEST = \"10m\"\nexport const DEFAULT_CPU_LIMIT = \"500m\"\nexport const DEFAULT_MEMORY_REQUEST = \"128Mi\"\nexport const DEFAULT_MEMORY_LIMIT = \"512Mi\"\n\ninterface KubeEnvVar {\n  name: string\n  value?: string\n  valueFrom?: { fieldRef: { fieldPath: string } }\n}\n\nexport async function getContainerServiceStatus(\n  { ctx, module, service, runtimeContext }: GetServiceStatusParams<ContainerModule>,\n): Promise<ServiceStatus> {\n  // TODO: hash and compare all the configuration files (otherwise internal changes don't get deployed)\n  const version = module.version\n  const objects = await createContainerObjects(ctx, service, runtimeContext)\n  const matched = await compareDeployedObjects(ctx, objects)\n  const api = new KubeApi(ctx.provider)\n  const ingresses = await getIngresses(service, api)\n\n  return {\n    ingresses,\n    state: matched ? \"ready\" : \"outdated\",\n    version: matched ? version.versionString : undefined,\n  }\n}\n\nexport async function deployContainerService(params: DeployServiceParams<ContainerModule>): Promise<ServiceStatus> {\n  const { ctx, service, runtimeContext, force, logEntry } = params\n\n  const provider = ctx.provider\n  const namespace = await getAppNamespace(ctx, provider)\n  const objects = await createContainerObjects(ctx, service, runtimeContext)\n\n  // TODO: use Helm instead of kubectl apply\n  const pruneSelector = \"service=\" + service.name\n  await applyMany(provider.config.context, objects, { force, namespace, pruneSelector })\n  await waitForObjects({ ctx, provider, service, objects, logEntry })\n\n  return getContainerServiceStatus(params)\n}\n\nexport async function createContainerObjects(\n  ctx: PluginContext, service: ContainerService, runtimeContext: RuntimeContext,\n) {\n  const version = service.module.version\n  const provider = ctx.provider\n  const namespace = await getAppNamespace(ctx, provider)\n  const deployment = await createDeployment(provider, service, runtimeContext, namespace)\n  const kubeservices = await createServices(service, namespace)\n  const api = new KubeApi(provider)\n  const ingresses = await createIngresses(api, namespace, service)\n\n  const objects = [deployment, ...kubeservices, ...ingresses]\n\n  return objects.map(obj => {\n    set(obj, [\"metadata\", \"annotations\", \"garden.io/generated\"], \"true\")\n    set(obj, [\"metadata\", \"annotations\", GARDEN_ANNOTATION_KEYS_VERSION], version.versionString)\n    set(obj, [\"metadata\", \"labels\", \"module\"], service.module.name)\n    set(obj, [\"metadata\", \"labels\", \"service\"], service.name)\n    return obj\n  })\n}\n\nexport async function createDeployment(\n  provider: KubernetesProvider, service: ContainerService, runtimeContext: RuntimeContext, namespace: string,\n): Promise<KubernetesObject> {\n  const spec = service.spec\n  // TODO: support specifying replica count\n  const configuredReplicas = 1 // service.spec.count[env.name] || 1\n\n  const labels = {\n    module: service.module.name,\n    service: service.name,\n  }\n\n  // TODO: moar type-safety\n  const deployment: any = {\n    kind: \"Deployment\",\n    apiVersion: \"extensions/v1beta1\",\n    metadata: {\n      name: service.name,\n      annotations: {\n        // we can use this to avoid overriding the replica count if it has been manually scaled\n        \"garden.io/configured.replicas\": configuredReplicas.toString(),\n      },\n      namespace,\n      labels,\n    },\n    spec: {\n      selector: {\n        matchLabels: {\n          service: service.name,\n        },\n      },\n      template: {\n        metadata: {\n          labels,\n        },\n        spec: {\n          // TODO: set this for non-system pods\n          // automountServiceAccountToken: false,  // this prevents the pod from accessing the kubernetes API\n          containers: [],\n          // TODO: make restartPolicy configurable\n          restartPolicy: \"Always\",\n          terminationGracePeriodSeconds: 10,\n          dnsPolicy: \"ClusterFirst\",\n        },\n      },\n    },\n  }\n\n  const envVars = { ...runtimeContext.envVars, ...service.spec.env }\n\n  const env: KubeEnvVar[] = toPairs(envVars).map(([name, value]) => ({ name, value: value + \"\" }))\n\n  // expose some metadata to the container\n  env.push({\n    name: \"POD_NAME\",\n    valueFrom: { fieldRef: { fieldPath: \"metadata.name\" } },\n  })\n\n  env.push({\n    name: \"POD_NAMESPACE\",\n    valueFrom: { fieldRef: { fieldPath: \"metadata.namespace\" } },\n  })\n\n  env.push({\n    name: \"POD_IP\",\n    valueFrom: { fieldRef: { fieldPath: \"status.podIP\" } },\n  })\n\n  const registryConfig = provider.name === \"local-kubernetes\" ? undefined : provider.config.deploymentRegistry\n  const image = await helpers.getDeploymentImageId(service.module, registryConfig)\n\n  const container: any = {\n    name: service.name,\n    image,\n    env,\n    ports: [],\n    // TODO: make these configurable\n    resources: {\n      requests: {\n        cpu: DEFAULT_CPU_REQUEST,\n        memory: DEFAULT_MEMORY_REQUEST,\n      },\n      limits: {\n        cpu: DEFAULT_CPU_LIMIT,\n        memory: DEFAULT_MEMORY_LIMIT,\n      },\n    },\n    imagePullPolicy: \"IfNotPresent\",\n  }\n\n  if (service.spec.command && service.spec.command.length > 0) {\n    container.args = service.spec.command\n  }\n\n  // if (config.entrypoint) {\n  //   container.command = [config.entrypoint]\n  // }\n\n  if (spec.healthCheck) {\n    container.readinessProbe = {\n      initialDelaySeconds: 10,\n      periodSeconds: 5,\n      timeoutSeconds: 3,\n      successThreshold: 2,\n      failureThreshold: 5,\n    }\n\n    container.livenessProbe = {\n      initialDelaySeconds: 15,\n      periodSeconds: 5,\n      timeoutSeconds: 3,\n      successThreshold: 1,\n      failureThreshold: 3,\n    }\n\n    const portsByName = keyBy(spec.ports, \"name\")\n\n    if (spec.healthCheck.httpGet) {\n      const httpGet: any = extend({}, spec.healthCheck.httpGet)\n      httpGet.port = portsByName[httpGet.port].containerPort\n\n      container.readinessProbe.httpGet = httpGet\n      container.livenessProbe.httpGet = httpGet\n    } else if (spec.healthCheck.command) {\n      container.readinessProbe.exec = { command: spec.healthCheck.command.map(s => s.toString()) }\n      container.livenessProbe.exec = container.readinessProbe.exec\n    } else if (spec.healthCheck.tcpPort) {\n      container.readinessProbe.tcpSocket = {\n        port: portsByName[spec.healthCheck.tcpPort].containerPort,\n      }\n      container.livenessProbe.tcpSocket = container.readinessProbe.tcpSocket\n    } else {\n      throw new Error(\"Must specify type of health check when configuring health check.\")\n    }\n  }\n\n  // if (service.privileged) {\n  //   container.securityContext = {\n  //     privileged: true,\n  //   }\n  // }\n\n  if (spec.volumes && spec.volumes.length) {\n    const volumes: any[] = []\n    const volumeMounts: any[] = []\n\n    for (const volume of spec.volumes) {\n      const volumeName = volume.name\n      const volumeType = !!volume.hostPath ? \"hostPath\" : \"emptyDir\"\n\n      if (!volumeName) {\n        throw new Error(\"Must specify volume name\")\n      }\n\n      if (volumeType === \"emptyDir\") {\n        volumes.push({\n          name: volumeName,\n          emptyDir: {},\n        })\n        volumeMounts.push({\n          name: volumeName,\n          mountPath: volume.containerPath,\n        })\n      } else if (volumeType === \"hostPath\") {\n        volumes.push({\n          name: volumeName,\n          hostPath: {\n            path: volume.hostPath,\n          },\n        })\n        volumeMounts.push({\n          name: volumeName,\n          mountPath: volume.containerPath || volume.hostPath,\n        })\n      } else {\n        throw new Error(\"Unsupported volume type: \" + volumeType)\n      }\n    }\n\n    deployment.spec.template.spec.volumes = volumes\n    container.volumeMounts = volumeMounts\n  }\n\n  const ports = spec.ports\n\n  for (const port of ports) {\n    container.ports.push({\n      protocol: port.protocol,\n      containerPort: port.containerPort,\n    })\n  }\n\n  if (spec.daemon) {\n    // this runs a pod on every node\n    deployment.kind = \"DaemonSet\"\n    deployment.spec.updateStrategy = {\n      type: \"RollingUpdate\",\n    }\n\n    for (const port of ports.filter(p => p.hostPort)) {\n      // For daemons we can expose host ports directly on the Pod, as opposed to only via the Service resource.\n      // This allows us to choose any port.\n      // TODO: validate that conflicting ports are not defined.\n      container.ports.push({\n        protocol: port.protocol,\n        containerPort: port.containerPort,\n        hostPort: port.hostPort,\n      })\n    }\n\n  } else {\n    deployment.spec.replicas = configuredReplicas\n    deployment.spec.strategy = {\n      type: \"RollingUpdate\",\n      rollingUpdate: {\n        maxUnavailable: \"34%\",\n        maxSurge: \"34%\",\n      },\n    }\n    deployment.spec.revisionHistoryLimit = 3\n  }\n\n  if (provider.config.imagePullSecrets.length > 0) {\n    // add any configured imagePullSecrets\n    deployment.spec.template.spec.imagePullSecrets = provider.config.imagePullSecrets.map(s => ({ name: s.name }))\n  }\n\n  deployment.spec.template.spec.containers = [container]\n\n  return deployment\n}\n\nexport async function deleteContainerService(\n  { namespace, provider, serviceName, logEntry },\n) {\n\n  const context = provider.config.context\n  await deleteContainerDeployment({ namespace, provider, serviceName, logEntry })\n  await deleteObjectsByLabel({\n    context,\n    namespace,\n    labelKey: \"service\",\n    labelValue: serviceName,\n    objectTypes: [\"deployment\", \"service\", \"ingress\"],\n    includeUninitialized: false,\n  })\n\n}\n\nexport async function deleteContainerDeployment(\n  { namespace, provider, serviceName, logEntry },\n) {\n\n  let found = true\n  const api = new KubeApi(provider)\n\n  try {\n    await api.extensions.deleteNamespacedDeployment(serviceName, namespace, <any>{})\n  } catch (err) {\n    if (err.code === 404) {\n      found = false\n    } else {\n      throw err\n    }\n  }\n\n  if (logEntry) {\n    found ? logEntry.setSuccess(\"Service deleted\") : logEntry.setWarn(\"Service not deployed\")\n  }\n}\n\nexport async function pushModule({ ctx, module, logEntry }: PushModuleParams<ContainerModule>) {\n  if (!(await helpers.hasDockerfile(module))) {\n    logEntry && logEntry.setState({ msg: `Nothing to push` })\n    return { pushed: false }\n  }\n\n  const localId = await helpers.getLocalImageId(module)\n  const remoteId = await helpers.getDeploymentImageId(module, ctx.provider.config.deploymentRegistry)\n\n  logEntry && logEntry.setState({ msg: `Pushing image ${remoteId}...` })\n\n  await helpers.dockerCli(module, `tag ${localId} ${remoteId}`)\n  await helpers.dockerCli(module, `push ${remoteId}`)\n\n  return { pushed: true, message: `Pushed ${localId}` }\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/helm.d.ts b/garden-service/build/plugins/kubernetes/helm.d.ts new file mode 100644 index 00000000000..48f9776585e --- /dev/null +++ b/garden-service/build/plugins/kubernetes/helm.d.ts @@ -0,0 +1,31 @@ +import { Primitive } from "../../config/common"; +import { Module } from "../../types/module"; +import { ModuleAndServiceActions } from "../../types/plugin/plugin"; +import { KubernetesProvider } from "./kubernetes"; +import { ServiceSpec } from "../../config/service"; +export interface KubernetesObject { + apiVersion: string; + kind: string; + metadata: { + annotations?: object; + name: string; + namespace?: string; + labels?: object; + }; + spec?: any; +} +export interface HelmServiceSpec extends ServiceSpec { + chart: string; + repo?: string; + dependencies: string[]; + version?: string; + parameters: { + [key: string]: Primitive; + }; +} +export declare type HelmModuleSpec = HelmServiceSpec; +export interface HelmModule extends Module { +} +export declare const helmHandlers: Partial>; +export declare function helm(provider: KubernetesProvider, ...args: string[]): Promise; +//# sourceMappingURL=helm.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/helm.js b/garden-service/build/plugins/kubernetes/helm.js new file mode 100644 index 00000000000..a2655cab199 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/helm.js @@ -0,0 +1,224 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const execa = require("execa"); +const Joi = require("joi"); +const js_yaml_1 = require("js-yaml"); +const lodash_1 = require("lodash"); +const path_1 = require("path"); +const common_1 = require("../../config/common"); +const util_1 = require("../../util/util"); +const namespace_1 = require("./namespace"); +const constants_1 = require("../../constants"); +const base_1 = require("../../vcs/base"); +const status_1 = require("./status"); +const generic_1 = require("../generic"); +const api_1 = require("./api"); +const parameterValueSchema = Joi.alternatives(common_1.joiPrimitive(), Joi.array().items(Joi.lazy(() => parameterValueSchema)), Joi.object().pattern(/.+/, Joi.lazy(() => parameterValueSchema))); +const helmModuleSpecSchema = Joi.object().keys({ + // TODO: support placing a helm chart in the module directory + chart: Joi.string() + .required() + .description("A valid Helm chart name or URI."), + repo: Joi.string() + .description("The repository URL to fetch the chart from."), + dependencies: common_1.joiArray(common_1.joiIdentifier()) + .description("List of names of services that should be deployed before this chart."), + version: Joi.string() + .description("The chart version to deploy."), + parameters: Joi.object() + .pattern(/.+/, parameterValueSchema) + .default(() => ({}), "{}") + .description("Map of parameters to pass to Helm when rendering the templates. May include arrays and nested objects."), +}); +const helmStatusCodeMap = { + // see https://github.com/kubernetes/helm/blob/master/_proto/hapi/release/status.proto + 0: "unknown", + 1: "ready", + 2: "missing", + 3: "stopped", + 4: "unhealthy", + 5: "stopped", + 6: "deploying", + 7: "deploying", + 8: "deploying", +}; +exports.helmHandlers = { + validate({ moduleConfig }) { + return __awaiter(this, void 0, void 0, function* () { + moduleConfig.spec = common_1.validate(moduleConfig.spec, helmModuleSpecSchema, { context: `helm module ${moduleConfig.name}` }); + const { chart, version, parameters, dependencies } = moduleConfig.spec; + moduleConfig.serviceConfigs = [{ + name: moduleConfig.name, + dependencies, + outputs: {}, + spec: { chart, version, parameters, dependencies }, + }]; + // TODO: make sure at least either a chart is specified, or module contains a helm chart + return moduleConfig; + }); + }, + getBuildStatus: generic_1.getGenericModuleBuildStatus, + build, + getServiceStatus, + deployService({ ctx, module, service, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const provider = ctx.provider; + const chartPath = yield getChartPath(module); + const valuesPath = getValuesPath(chartPath); + const namespace = yield namespace_1.getAppNamespace(ctx, ctx.provider); + const releaseName = getReleaseName(namespace, service); + const releaseStatus = yield getReleaseStatus(ctx.provider, releaseName); + if (releaseStatus.state === "missing") { + yield helm(provider, "install", chartPath, "--name", releaseName, "--namespace", namespace, "--values", valuesPath, "--wait"); + } + else { + yield helm(provider, "upgrade", releaseName, chartPath, "--namespace", namespace, "--values", valuesPath, "--wait"); + } + const objects = yield getChartObjects(ctx, service); + yield status_1.waitForObjects({ ctx, provider, service, objects, logEntry }); + return {}; + }); + }, + deleteService(params) { + return __awaiter(this, void 0, void 0, function* () { + const { ctx, logEntry, service } = params; + const namespace = yield namespace_1.getAppNamespace(ctx, ctx.provider); + const releaseName = getReleaseName(namespace, service); + yield helm(ctx.provider, "delete", "--purge", releaseName); + logEntry && logEntry.setSuccess("Service deleted"); + return yield getServiceStatus(params); + }); + }, +}; +function build({ ctx, module, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const buildPath = module.buildPath; + const config = module; + // fetch the chart + const fetchArgs = [ + "fetch", config.spec.chart, + "--destination", buildPath, + "--untar", + ]; + if (config.spec.version) { + fetchArgs.push("--version", config.spec.version); + } + if (config.spec.repo) { + fetchArgs.push("--repo", config.spec.repo); + } + logEntry && logEntry.setState("Fetching chart..."); + yield helm(ctx.provider, ...fetchArgs); + const chartPath = yield getChartPath(module); + // create the values.yml file (merge the configured parameters into the default values) + logEntry && logEntry.setState("Preparing chart..."); + const values = js_yaml_1.safeLoad(yield helm(ctx.provider, "inspect", "values", chartPath)) || {}; + Object.entries(flattenValues(config.spec.parameters)) + .map(([k, v]) => lodash_1.set(values, k, v)); + const valuesPath = getValuesPath(chartPath); + yield util_1.dumpYaml(valuesPath, values); + // keep track of which version has been built + const buildVersionFilePath = path_1.join(buildPath, constants_1.GARDEN_BUILD_VERSION_FILENAME); + const version = module.version; + yield base_1.writeTreeVersionFile(buildVersionFilePath, { + latestCommit: version.versionString, + dirtyTimestamp: version.dirtyTimestamp, + }); + return { fresh: true }; + }); +} +function helm(provider, ...args) { + return execa.stdout("helm", [ + "--kube-context", provider.config.context, + ...args, + ]); +} +exports.helm = helm; +function getChartPath(module) { + return __awaiter(this, void 0, void 0, function* () { + const splitName = module.spec.chart.split("/"); + const chartDir = splitName[splitName.length - 1]; + return path_1.join(module.buildPath, chartDir); + }); +} +function getValuesPath(chartPath) { + return path_1.join(chartPath, "garden-values.yml"); +} +function getChartObjects(ctx, service) { + return __awaiter(this, void 0, void 0, function* () { + const chartPath = yield getChartPath(service.module); + const valuesPath = getValuesPath(chartPath); + const namespace = yield namespace_1.getAppNamespace(ctx, ctx.provider); + const releaseName = getReleaseName(namespace, service); + const objects = js_yaml_1.safeLoadAll(yield helm(ctx.provider, "template", "--name", releaseName, "--namespace", namespace, "--values", valuesPath, chartPath)); + return objects.filter(obj => obj !== null).map((obj) => { + if (!obj.metadata.annotations) { + obj.metadata.annotations = {}; + } + return obj; + }); + }); +} +function getServiceStatus({ ctx, service, module, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + // need to build to be able to check the status + const buildStatus = yield generic_1.getGenericModuleBuildStatus({ ctx, module, logEntry }); + if (!buildStatus.ready) { + yield build({ ctx, module, logEntry }); + } + // first check if the installed objects on the cluster match the current code + const objects = yield getChartObjects(ctx, service); + const matched = yield status_1.compareDeployedObjects(ctx, objects); + if (!matched) { + return { state: "outdated" }; + } + // then check if the rollout is complete + const version = module.version; + const api = new api_1.KubeApi(ctx.provider); + const namespace = yield namespace_1.getAppNamespace(ctx, ctx.provider); + const { ready } = yield status_1.checkObjectStatus(api, namespace, objects); + // TODO: set state to "unhealthy" if any status is "unhealthy" + const state = ready ? "ready" : "deploying"; + return { state, version: version.versionString }; + }); +} +function getReleaseName(namespace, service) { + return `${namespace}--${service.name}`; +} +function getReleaseStatus(provider, releaseName) { + return __awaiter(this, void 0, void 0, function* () { + try { + const res = JSON.parse(yield helm(provider, "status", releaseName, "--output", "json")); + const statusCode = res.info.status.code; + return { + state: helmStatusCodeMap[statusCode], + detail: res, + }; + } + catch (_) { + // release doesn't exist + return { state: "missing" }; + } + }); +} +// adapted from https://gist.github.com/penguinboy/762197 +function flattenValues(object, prefix = "") { + return Object.keys(object).reduce((prev, element) => object[element] && typeof object[element] === "object" && !Array.isArray(object[element]) + ? Object.assign({}, prev, flattenValues(object[element], `${prefix}${element}.`)) : Object.assign({}, prev, { [`${prefix}${element}`]: object[element] }), {}); +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/kubernetes/helm.ts"],"names":[],"mappings":"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","file":"plugins/kubernetes/helm.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport execa = require(\"execa\")\nimport * as Joi from \"joi\"\nimport {\n  safeLoad,\n  safeLoadAll,\n} from \"js-yaml\"\nimport { set } from \"lodash\"\nimport { join } from \"path\"\nimport { PluginContext } from \"../../plugin-context\"\nimport {\n  joiArray,\n  joiIdentifier,\n  joiPrimitive,\n  Primitive,\n  validate,\n} from \"../../config/common\"\nimport { Module } from \"../../types/module\"\nimport { ModuleAndServiceActions } from \"../../types/plugin/plugin\"\nimport {\n  BuildModuleParams,\n  DeployServiceParams,\n  GetServiceStatusParams,\n  ValidateModuleParams,\n  DeleteServiceParams,\n} from \"../../types/plugin/params\"\nimport {\n  BuildResult,\n  ValidateModuleResult,\n} from \"../../types/plugin/outputs\"\nimport { Service, ServiceStatus } from \"../../types/service\"\nimport { dumpYaml } from \"../../util/util\"\nimport { KubernetesProvider } from \"./kubernetes\"\nimport { getAppNamespace } from \"./namespace\"\nimport { GARDEN_BUILD_VERSION_FILENAME } from \"../../constants\"\nimport { writeTreeVersionFile } from \"../../vcs/base\"\nimport { ServiceState } from \"../../types/service\"\nimport { compareDeployedObjects, waitForObjects, checkObjectStatus } from \"./status\"\nimport { getGenericModuleBuildStatus } from \"../generic\"\nimport { ServiceSpec } from \"../../config/service\"\nimport { KubeApi } from \"./api\"\n\nexport interface KubernetesObject {\n  apiVersion: string\n  kind: string\n  metadata: {\n    annotations?: object,\n    name: string,\n    namespace?: string,\n    labels?: object,\n  }\n  spec?: any\n}\n\nexport interface HelmServiceSpec extends ServiceSpec {\n  chart: string\n  repo?: string\n  dependencies: string[]\n  version?: string\n  parameters: { [key: string]: Primitive }\n}\n\nexport type HelmModuleSpec = HelmServiceSpec\n\nexport interface HelmModule extends Module<HelmModuleSpec, HelmServiceSpec> { }\n\nconst parameterValueSchema = Joi.alternatives(\n  joiPrimitive(),\n  Joi.array().items(Joi.lazy(() => parameterValueSchema)),\n  Joi.object().pattern(/.+/, Joi.lazy(() => parameterValueSchema)),\n)\n\nconst helmModuleSpecSchema = Joi.object().keys({\n  // TODO: support placing a helm chart in the module directory\n  chart: Joi.string()\n    .required()\n    .description(\"A valid Helm chart name or URI.\"),\n  repo: Joi.string()\n    .description(\"The repository URL to fetch the chart from.\"),\n  dependencies: joiArray(joiIdentifier())\n    .description(\"List of names of services that should be deployed before this chart.\"),\n  version: Joi.string()\n    .description(\"The chart version to deploy.\"),\n  parameters: Joi.object()\n    .pattern(/.+/, parameterValueSchema)\n    .default(() => ({}), \"{}\")\n    .description(\n      \"Map of parameters to pass to Helm when rendering the templates. May include arrays and nested objects.\",\n    ),\n})\n\nconst helmStatusCodeMap: { [code: number]: ServiceState } = {\n  // see https://github.com/kubernetes/helm/blob/master/_proto/hapi/release/status.proto\n  0: \"unknown\",   // UNKNOWN\n  1: \"ready\",     // DEPLOYED\n  2: \"missing\",   // DELETED\n  3: \"stopped\",   // SUPERSEDED\n  4: \"unhealthy\", // FAILED\n  5: \"stopped\",   // DELETING\n  6: \"deploying\", // PENDING_INSTALL\n  7: \"deploying\", // PENDING_UPGRADE\n  8: \"deploying\", // PENDING_ROLLBACK\n}\n\nexport const helmHandlers: Partial<ModuleAndServiceActions<HelmModule>> = {\n  async validate({ moduleConfig }: ValidateModuleParams): Promise<ValidateModuleResult> {\n    moduleConfig.spec = validate(\n      moduleConfig.spec,\n      helmModuleSpecSchema,\n      { context: `helm module ${moduleConfig.name}` },\n    )\n\n    const { chart, version, parameters, dependencies } = moduleConfig.spec\n\n    moduleConfig.serviceConfigs = [{\n      name: moduleConfig.name,\n      dependencies,\n      outputs: {},\n      spec: { chart, version, parameters, dependencies },\n    }]\n\n    // TODO: make sure at least either a chart is specified, or module contains a helm chart\n    return moduleConfig\n  },\n\n  getBuildStatus: getGenericModuleBuildStatus,\n  build,\n  getServiceStatus,\n\n  async deployService(\n    { ctx, module, service, logEntry }: DeployServiceParams<HelmModule>,\n  ): Promise<ServiceStatus> {\n    const provider = ctx.provider\n    const chartPath = await getChartPath(module)\n    const valuesPath = getValuesPath(chartPath)\n    const namespace = await getAppNamespace(ctx, ctx.provider)\n    const releaseName = getReleaseName(namespace, service)\n\n    const releaseStatus = await getReleaseStatus(ctx.provider, releaseName)\n\n    if (releaseStatus.state === \"missing\") {\n      await helm(provider,\n        \"install\", chartPath,\n        \"--name\", releaseName,\n        \"--namespace\", namespace,\n        \"--values\", valuesPath,\n        \"--wait\",\n      )\n    } else {\n      await helm(provider,\n        \"upgrade\", releaseName, chartPath,\n        \"--namespace\", namespace,\n        \"--values\", valuesPath,\n        \"--wait\",\n      )\n    }\n\n    const objects = await getChartObjects(ctx, service)\n    await waitForObjects({ ctx, provider, service, objects, logEntry })\n\n    return {}\n  },\n\n  async deleteService(params: DeleteServiceParams): Promise<ServiceStatus> {\n    const { ctx, logEntry, service } = params\n    const namespace = await getAppNamespace(ctx, ctx.provider)\n    const releaseName = getReleaseName(namespace, service)\n    await helm(ctx.provider, \"delete\", \"--purge\", releaseName)\n    logEntry && logEntry.setSuccess(\"Service deleted\")\n\n    return await getServiceStatus(params)\n  },\n}\n\nasync function build({ ctx, module, logEntry }: BuildModuleParams<HelmModule>): Promise<BuildResult> {\n  const buildPath = module.buildPath\n  const config = module\n\n  // fetch the chart\n  const fetchArgs = [\n    \"fetch\", config.spec.chart,\n    \"--destination\", buildPath,\n    \"--untar\",\n  ]\n  if (config.spec.version) {\n    fetchArgs.push(\"--version\", config.spec.version)\n  }\n  if (config.spec.repo) {\n    fetchArgs.push(\"--repo\", config.spec.repo)\n  }\n  logEntry && logEntry.setState(\"Fetching chart...\")\n  await helm(ctx.provider, ...fetchArgs)\n\n  const chartPath = await getChartPath(module)\n\n  // create the values.yml file (merge the configured parameters into the default values)\n  logEntry && logEntry.setState(\"Preparing chart...\")\n  const values = safeLoad(await helm(ctx.provider, \"inspect\", \"values\", chartPath)) || {}\n\n  Object.entries(flattenValues(config.spec.parameters))\n    .map(([k, v]) => set(values, k, v))\n\n  const valuesPath = getValuesPath(chartPath)\n  await dumpYaml(valuesPath, values)\n\n  // keep track of which version has been built\n  const buildVersionFilePath = join(buildPath, GARDEN_BUILD_VERSION_FILENAME)\n  const version = module.version\n  await writeTreeVersionFile(buildVersionFilePath, {\n    latestCommit: version.versionString,\n    dirtyTimestamp: version.dirtyTimestamp,\n  })\n\n  return { fresh: true }\n}\n\nexport function helm(provider: KubernetesProvider, ...args: string[]) {\n  return execa.stdout(\"helm\", [\n    \"--kube-context\", provider.config.context,\n    ...args,\n  ])\n}\n\nasync function getChartPath(module: HelmModule) {\n  const splitName = module.spec.chart.split(\"/\")\n  const chartDir = splitName[splitName.length - 1]\n  return join(module.buildPath, chartDir)\n}\n\nfunction getValuesPath(chartPath: string) {\n  return join(chartPath, \"garden-values.yml\")\n}\n\nasync function getChartObjects(ctx: PluginContext, service: Service) {\n  const chartPath = await getChartPath(service.module)\n  const valuesPath = getValuesPath(chartPath)\n  const namespace = await getAppNamespace(ctx, ctx.provider)\n  const releaseName = getReleaseName(namespace, service)\n\n  const objects = <KubernetesObject[]>safeLoadAll(await helm(ctx.provider,\n    \"template\",\n    \"--name\", releaseName,\n    \"--namespace\", namespace,\n    \"--values\", valuesPath,\n    chartPath,\n  ))\n\n  return objects.filter(obj => obj !== null).map((obj) => {\n    if (!obj.metadata.annotations) {\n      obj.metadata.annotations = {}\n    }\n    return obj\n  })\n}\n\nasync function getServiceStatus(\n  { ctx, service, module, logEntry }: GetServiceStatusParams<HelmModule>,\n): Promise<ServiceStatus> {\n  // need to build to be able to check the status\n  const buildStatus = await getGenericModuleBuildStatus({ ctx, module, logEntry })\n  if (!buildStatus.ready) {\n    await build({ ctx, module, logEntry })\n  }\n\n  // first check if the installed objects on the cluster match the current code\n  const objects = await getChartObjects(ctx, service)\n  const matched = await compareDeployedObjects(ctx, objects)\n\n  if (!matched) {\n    return { state: \"outdated\" }\n  }\n\n  // then check if the rollout is complete\n  const version = module.version\n  const api = new KubeApi(ctx.provider)\n  const namespace = await getAppNamespace(ctx, ctx.provider)\n  const { ready } = await checkObjectStatus(api, namespace, objects)\n\n  // TODO: set state to \"unhealthy\" if any status is \"unhealthy\"\n  const state = ready ? \"ready\" : \"deploying\"\n\n  return { state, version: version.versionString }\n}\n\nfunction getReleaseName(namespace: string, service: Service) {\n  return `${namespace}--${service.name}`\n}\n\nasync function getReleaseStatus(provider: KubernetesProvider, releaseName: string): Promise<ServiceStatus> {\n  try {\n    const res = JSON.parse(await helm(provider, \"status\", releaseName, \"--output\", \"json\"))\n    const statusCode = res.info.status.code\n    return {\n      state: helmStatusCodeMap[statusCode],\n      detail: res,\n    }\n  } catch (_) {\n    // release doesn't exist\n    return { state: \"missing\" }\n  }\n}\n\n// adapted from https://gist.github.com/penguinboy/762197\nfunction flattenValues(object, prefix = \"\") {\n  return Object.keys(object).reduce(\n    (prev, element) =>\n      object[element] && typeof object[element] === \"object\" && !Array.isArray(object[element])\n        ? { ...prev, ...flattenValues(object[element], `${prefix}${element}.`) }\n        : { ...prev, ...{ [`${prefix}${element}`]: object[element] } },\n    {},\n  )\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/ingress.d.ts b/garden-service/build/plugins/kubernetes/ingress.d.ts new file mode 100644 index 00000000000..d7eff86651e --- /dev/null +++ b/garden-service/build/plugins/kubernetes/ingress.d.ts @@ -0,0 +1,18 @@ +import { ContainerService } from "../container"; +import { ServiceIngress } from "../../types/service"; +import { KubeApi } from "./api"; +export declare function createIngresses(api: KubeApi, namespace: string, service: ContainerService): Promise<{ + apiVersion: string; + kind: string; + metadata: { + name: string; + annotations: { + "kubernetes.io/ingress.class": string; + "ingress.kubernetes.io/force-ssl-redirect": string; + }; + namespace: string; + }; + spec: any; +}[]>; +export declare function getIngresses(service: ContainerService, api: KubeApi): Promise; +//# sourceMappingURL=ingress.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/ingress.js b/garden-service/build/plugins/kubernetes/ingress.js new file mode 100644 index 00000000000..ca87f7970a6 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/ingress.js @@ -0,0 +1,180 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const util_1 = require("../../util/util"); +const Bluebird = require("bluebird"); +const exceptions_1 = require("../../exceptions"); +const certpem_1 = require("certpem"); +const secrets_1 = require("./secrets"); +const certificateHostnames = {}; +function createIngresses(api, namespace, service) { + return __awaiter(this, void 0, void 0, function* () { + if (service.spec.ingresses.length === 0) { + return []; + } + const allIngresses = yield getIngressesWithCert(service, api); + // first group ingress endpoints by certificate, so we can properly configure TLS + const groupedByCert = lodash_1.groupBy(allIngresses, e => e.certificate ? e.certificate.name : undefined); + return Bluebird.map(Object.values(groupedByCert), (certIngresses) => __awaiter(this, void 0, void 0, function* () { + // second, group ingress endpoints by hostname + const groupedByHostname = lodash_1.groupBy(certIngresses, e => e.hostname); + const rules = Object.entries(groupedByHostname).map(([host, hostnameIngresses]) => ({ + host, + http: { + paths: hostnameIngresses.map(ingress => ({ + path: ingress.path, + backend: { + serviceName: service.name, + servicePort: util_1.findByName(service.spec.ports, ingress.spec.port).containerPort, + }, + })), + }, + })); + const cert = certIngresses[0].certificate; + const annotations = { + "kubernetes.io/ingress.class": api.provider.config.ingressClass, + "ingress.kubernetes.io/force-ssl-redirect": !!cert + "", + }; + const spec = { rules }; + if (!!cert) { + // make sure the TLS secrets exist in this namespace + yield secrets_1.ensureSecret(api, cert.secretRef, namespace); + spec.tls = [{ + secretName: cert.secretRef.name, + }]; + } + return { + apiVersion: "extensions/v1beta1", + kind: "Ingress", + metadata: { + name: service.name, + annotations, + namespace, + }, + spec, + }; + })); + }); +} +exports.createIngresses = createIngresses; +function getIngress(service, api, spec) { + return __awaiter(this, void 0, void 0, function* () { + const hostname = spec.hostname || api.provider.config.defaultHostname; + if (!hostname) { + // this should be caught when parsing the module + throw new exceptions_1.PluginError(`Missing hostname in ingress spec`, { serviceSpec: service.spec, ingressSpec: spec }); + } + const certificate = yield pickCertificate(service, api, hostname); + // TODO: support other protocols + const protocol = !!certificate ? "https" : "http"; + const port = !!certificate ? api.provider.config.ingressHttpsPort : api.provider.config.ingressHttpPort; + return Object.assign({}, spec, { certificate, + hostname, path: spec.path, port, + protocol, + spec }); + }); +} +function getIngressesWithCert(service, api) { + return __awaiter(this, void 0, void 0, function* () { + return Bluebird.map(service.spec.ingresses, spec => getIngress(service, api, spec)); + }); +} +function getIngresses(service, api) { + return __awaiter(this, void 0, void 0, function* () { + return (yield getIngressesWithCert(service, api)) + .map(e => lodash_1.omit(e, ["certificate", "spec"])); + }); +} +exports.getIngresses = getIngresses; +function getCertificateHostnames(api, cert) { + return __awaiter(this, void 0, void 0, function* () { + if (cert.hostnames) { + // use explicitly specified hostnames, if given + return cert.hostnames; + } + else if (certificateHostnames[cert.name]) { + // return cached hostnames if available + return certificateHostnames[cert.name]; + } + else { + // pull secret via secret ref from k8s + let res; + try { + res = yield api.core.readNamespacedSecret(cert.secretRef.name, cert.secretRef.namespace); + } + catch (err) { + if (err.code === 404) { + throw new exceptions_1.ConfigurationError(`Cannot find Secret ${cert.secretRef.name} configured for TLS certificate ${cert.name}`, cert); + } + else { + throw err; + } + } + const secret = res.body; + if (!secret.data["tls.crt"] || !secret.data["tls.key"]) { + throw new exceptions_1.ConfigurationError(`Secret '${cert.secretRef.name}' is not a valid TLS secret (missing tls.crt and/or tls.key).`, cert); + } + const crtData = Buffer.from(secret.data["tls.crt"], "base64").toString(); + try { + // Note: Can't use the certpem.info() method here because of multiple bugs. + // And yes, this API is insane. Crypto people are bonkers. Seriously. - JE + const certInfo = certpem_1.certpem.debug(crtData); + const hostnames = []; + const commonNameField = lodash_1.find(certInfo.subject.types_and_values, ["type", "2.5.4.3"]); + if (commonNameField) { + hostnames.push(commonNameField.value.value_block.value); + } + for (const ext of certInfo.extensions || []) { + if (ext.parsedValue && ext.parsedValue.altNames) { + for (const alt of ext.parsedValue.altNames) { + hostnames.push(alt.Name); + } + } + } + certificateHostnames[cert.name] = hostnames; + return hostnames; + } + catch (error) { + throw new exceptions_1.ConfigurationError(`Unable to parse Secret '${cert.secretRef.name}' as a valid TLS certificate`, Object.assign({}, cert, { error })); + } + } + }); +} +function pickCertificate(service, api, hostname) { + return __awaiter(this, void 0, void 0, function* () { + for (const cert of api.provider.config.tlsCertificates) { + const certHostnames = yield getCertificateHostnames(api, cert); + for (const certHostname of certHostnames) { + if (certHostname === hostname + || certHostname.startsWith("*") && hostname.endsWith(certHostname.slice(1))) { + return cert; + } + } + } + if (api.provider.config.forceSsl) { + throw new exceptions_1.ConfigurationError(`Could not find certificate for hostname '${hostname}' ` + + `configured on service '${service.name}' and forceSsl flag is set.`, { + serviceName: service.name, + hostname, + }); + } + return undefined; + }); +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/kubernetes/ingress.ts"],"names":[],"mappings":"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","file":"plugins/kubernetes/ingress.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { groupBy, omit, find } from \"lodash\"\nimport { findByName } from \"../../util/util\"\nimport { ContainerService, ContainerIngressSpec } from \"../container\"\nimport { IngressTlsCertificate } from \"./kubernetes\"\nimport { ServiceIngress, ServiceProtocol } from \"../../types/service\"\nimport * as Bluebird from \"bluebird\"\nimport { KubeApi } from \"./api\"\nimport { ConfigurationError, PluginError } from \"../../exceptions\"\nimport { certpem } from \"certpem\"\nimport { ensureSecret } from \"./secrets\"\n\ninterface ServiceIngressWithCert extends ServiceIngress {\n  spec: ContainerIngressSpec\n  certificate?: IngressTlsCertificate\n}\n\nconst certificateHostnames: { [name: string]: string[] } = {}\n\nexport async function createIngresses(api: KubeApi, namespace: string, service: ContainerService) {\n  if (service.spec.ingresses.length === 0) {\n    return []\n  }\n\n  const allIngresses = await getIngressesWithCert(service, api)\n\n  // first group ingress endpoints by certificate, so we can properly configure TLS\n  const groupedByCert = groupBy(allIngresses, e => e.certificate ? e.certificate.name : undefined)\n\n  return Bluebird.map(Object.values(groupedByCert), async (certIngresses) => {\n    // second, group ingress endpoints by hostname\n    const groupedByHostname = groupBy(certIngresses, e => e.hostname)\n\n    const rules = Object.entries(groupedByHostname).map(([host, hostnameIngresses]) => ({\n      host,\n      http: {\n        paths: hostnameIngresses.map(ingress => ({\n          path: ingress.path,\n          backend: {\n            serviceName: service.name,\n            servicePort: findByName(service.spec.ports, ingress.spec.port)!.containerPort,\n          },\n        })),\n      },\n    }))\n\n    const cert = certIngresses[0].certificate\n\n    const annotations = {\n      \"kubernetes.io/ingress.class\": api.provider.config.ingressClass,\n      \"ingress.kubernetes.io/force-ssl-redirect\": !!cert + \"\",\n    }\n\n    const spec: any = { rules }\n\n    if (!!cert) {\n      // make sure the TLS secrets exist in this namespace\n      await ensureSecret(api, cert.secretRef, namespace)\n\n      spec.tls = [{\n        secretName: cert.secretRef.name,\n      }]\n    }\n\n    return {\n      apiVersion: \"extensions/v1beta1\",\n      kind: \"Ingress\",\n      metadata: {\n        name: service.name,\n        annotations,\n        namespace,\n      },\n      spec,\n    }\n  })\n}\n\nasync function getIngress(\n  service: ContainerService, api: KubeApi, spec: ContainerIngressSpec,\n): Promise<ServiceIngressWithCert> {\n  const hostname = spec.hostname || api.provider.config.defaultHostname\n\n  if (!hostname) {\n    // this should be caught when parsing the module\n    throw new PluginError(`Missing hostname in ingress spec`, { serviceSpec: service.spec, ingressSpec: spec })\n  }\n\n  const certificate = await pickCertificate(service, api, hostname)\n  // TODO: support other protocols\n  const protocol: ServiceProtocol = !!certificate ? \"https\" : \"http\"\n  const port = !!certificate ? api.provider.config.ingressHttpsPort : api.provider.config.ingressHttpPort\n\n  return {\n    ...spec,\n    certificate,\n    hostname,\n    path: spec.path,\n    port,\n    protocol,\n    spec,\n  }\n}\n\nasync function getIngressesWithCert(service: ContainerService, api: KubeApi): Promise<ServiceIngressWithCert[]> {\n  return Bluebird.map(service.spec.ingresses, spec => getIngress(service, api, spec))\n}\n\nexport async function getIngresses(service: ContainerService, api: KubeApi): Promise<ServiceIngress[]> {\n  return (await getIngressesWithCert(service, api))\n    .map(e => omit(e, [\"certificate\", \"spec\"]))\n}\n\nasync function getCertificateHostnames(api: KubeApi, cert: IngressTlsCertificate): Promise<string[]> {\n  if (cert.hostnames) {\n    // use explicitly specified hostnames, if given\n    return cert.hostnames\n  } else if (certificateHostnames[cert.name]) {\n    // return cached hostnames if available\n    return certificateHostnames[cert.name]\n  } else {\n    // pull secret via secret ref from k8s\n    let res\n\n    try {\n      res = await api.core.readNamespacedSecret(cert.secretRef.name, cert.secretRef.namespace)\n    } catch (err) {\n      if (err.code === 404) {\n        throw new ConfigurationError(\n          `Cannot find Secret ${cert.secretRef.name} configured for TLS certificate ${cert.name}`,\n          cert,\n        )\n      } else {\n        throw err\n      }\n    }\n    const secret = res.body\n\n    if (!secret.data[\"tls.crt\"] || !secret.data[\"tls.key\"]) {\n      throw new ConfigurationError(\n        `Secret '${cert.secretRef.name}' is not a valid TLS secret (missing tls.crt and/or tls.key).`,\n        cert,\n      )\n    }\n\n    const crtData = Buffer.from(secret.data[\"tls.crt\"], \"base64\").toString()\n\n    try {\n      // Note: Can't use the certpem.info() method here because of multiple bugs.\n      // And yes, this API is insane. Crypto people are bonkers. Seriously. - JE\n      const certInfo = certpem.debug(crtData)\n\n      const hostnames: string[] = []\n\n      const commonNameField = find(certInfo.subject.types_and_values, [\"type\", \"2.5.4.3\"])\n      if (commonNameField) {\n        hostnames.push(commonNameField.value.value_block.value)\n      }\n\n      for (const ext of certInfo.extensions || []) {\n        if (ext.parsedValue && ext.parsedValue.altNames) {\n          for (const alt of ext.parsedValue.altNames) {\n            hostnames.push(alt.Name)\n          }\n        }\n      }\n\n      certificateHostnames[cert.name] = hostnames\n\n      return hostnames\n    } catch (error) {\n      throw new ConfigurationError(\n        `Unable to parse Secret '${cert.secretRef.name}' as a valid TLS certificate`,\n        { ...cert, error },\n      )\n    }\n  }\n}\n\nasync function pickCertificate(\n  service: ContainerService, api: KubeApi, hostname: string,\n): Promise<IngressTlsCertificate | undefined> {\n  for (const cert of api.provider.config.tlsCertificates) {\n    const certHostnames = await getCertificateHostnames(api, cert)\n\n    for (const certHostname of certHostnames) {\n      if (\n        certHostname === hostname\n        || certHostname.startsWith(\"*\") && hostname.endsWith(certHostname.slice(1))\n      ) {\n        return cert\n      }\n    }\n  }\n\n  if (api.provider.config.forceSsl) {\n    throw new ConfigurationError(\n      `Could not find certificate for hostname '${hostname}' ` +\n      `configured on service '${service.name}' and forceSsl flag is set.`,\n      {\n        serviceName: service.name,\n        hostname,\n      },\n    )\n  }\n\n  return undefined\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/init.d.ts b/garden-service/build/plugins/kubernetes/init.d.ts new file mode 100644 index 00000000000..213de36fba1 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/init.d.ts @@ -0,0 +1,13 @@ +import { PrepareEnvironmentParams, CleanupEnvironmentParams, GetEnvironmentStatusParams } from "../../types/plugin/params"; +export declare function getRemoteEnvironmentStatus({ ctx }: GetEnvironmentStatusParams): Promise<{ + ready: boolean; + needUserInput: boolean; +}>; +export declare function getLocalEnvironmentStatus({ ctx }: GetEnvironmentStatusParams): Promise<{ + ready: boolean; + needUserInput: boolean; +}>; +export declare function prepareRemoteEnvironment({ ctx, logEntry }: PrepareEnvironmentParams): Promise<{}>; +export declare function prepareLocalEnvironment({ ctx, force, logEntry }: PrepareEnvironmentParams): Promise<{}>; +export declare function cleanupEnvironment({ ctx, logEntry }: CleanupEnvironmentParams): Promise<{}>; +//# sourceMappingURL=init.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/init.js b/garden-service/build/plugins/kubernetes/init.js new file mode 100644 index 00000000000..3c3ee1c348a --- /dev/null +++ b/garden-service/build/plugins/kubernetes/init.js @@ -0,0 +1,275 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const inquirer = require("inquirer"); +const Joi = require("joi"); +const lodash_1 = require("lodash"); +const exceptions_1 = require("../../exceptions"); +const util_1 = require("../../util/util"); +const common_1 = require("../../config/common"); +const api_1 = require("./api"); +const namespace_1 = require("./namespace"); +const kubectl_1 = require("./kubectl"); +const kubernetes_1 = require("./kubernetes"); +const system_1 = require("./system"); +const helm_1 = require("./helm"); +const MAX_STORED_USERNAMES = 5; +/** + * Used by both the remote and local plugin + */ +function prepareNamespaces({ ctx }) { + return __awaiter(this, void 0, void 0, function* () { + const kubeContext = ctx.provider.config.context; + try { + // TODO: use API instead of kubectl (I just couldn't find which API call to make) + yield kubectl_1.kubectl(kubeContext).call(["version"]); + } + catch (err) { + // TODO: catch error properly + if (err.detail.output) { + throw new exceptions_1.DeploymentError(`Unable to connect to Kubernetes cluster. ` + + `Please make sure it is running, reachable and that you have the right context configured.`, { + kubeContext, + kubectlOutput: err.detail.output, + }); + } + throw err; + } + yield Bluebird.all([ + namespace_1.getMetadataNamespace(ctx, ctx.provider), + namespace_1.getAppNamespace(ctx, ctx.provider), + ]); + }); +} +function getRemoteEnvironmentStatus({ ctx }) { + return __awaiter(this, void 0, void 0, function* () { + const loggedIn = yield getLoginStatus({ ctx }); + if (!loggedIn) { + return { + ready: false, + needUserInput: true, + }; + } + yield prepareNamespaces({ ctx }); + return { + ready: true, + needUserInput: false, + }; + }); +} +exports.getRemoteEnvironmentStatus = getRemoteEnvironmentStatus; +function getLocalEnvironmentStatus({ ctx }) { + return __awaiter(this, void 0, void 0, function* () { + let ready = true; + let needUserInput = false; + yield prepareNamespaces({ ctx }); + // TODO: check if mkcert has been installed + // TODO: check if all certs have been generated + // check if system services are deployed + if (!system_1.isSystemGarden(ctx.provider)) { + const sysGarden = yield system_1.getSystemGarden(ctx.provider); + const sysStatus = yield sysGarden.actions.getStatus(); + const systemReady = sysStatus.providers[ctx.provider.config.name].ready && + lodash_1.every(lodash_1.values(sysStatus.services).map(s => s.state === "ready")); + if (!systemReady) { + ready = false; + } + } + return { + ready, + needUserInput, + }; + }); +} +exports.getLocalEnvironmentStatus = getLocalEnvironmentStatus; +function prepareRemoteEnvironment({ ctx, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const loggedIn = yield getLoginStatus({ ctx, logEntry }); + if (!loggedIn) { + yield login({ ctx, logEntry }); + } + return {}; + }); +} +exports.prepareRemoteEnvironment = prepareRemoteEnvironment; +function prepareLocalEnvironment({ ctx, force, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + // make sure system services are deployed + if (!system_1.isSystemGarden(ctx.provider)) { + yield configureSystemServices({ ctx, force, logEntry }); + } + // TODO: make sure all certs have been generated + return {}; + }); +} +exports.prepareLocalEnvironment = prepareLocalEnvironment; +function cleanupEnvironment({ ctx, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const api = new api_1.KubeApi(ctx.provider); + const namespace = yield namespace_1.getAppNamespace(ctx, ctx.provider); + const entry = logEntry && logEntry.info({ + section: "kubernetes", + msg: `Deleting namespace ${namespace} (this may take a while)`, + status: "active", + }); + try { + // Note: Need to call the delete method with an empty object + // TODO: any cast is required until https://github.com/kubernetes-client/javascript/issues/52 is fixed + yield api.core.deleteNamespace(namespace, {}); + } + catch (err) { + entry && entry.setError(err.message); + const availableNamespaces = yield namespace_1.getAllGardenNamespaces(api); + throw new exceptions_1.NotFoundError(err, { namespace, availableNamespaces }); + } + yield logout({ ctx, logEntry }); + // Wait until namespace has been deleted + const startTime = new Date().getTime(); + while (true) { + yield util_1.sleep(2000); + const nsNames = yield namespace_1.getAllGardenNamespaces(api); + if (!nsNames.includes(namespace)) { + break; + } + const now = new Date().getTime(); + if (now - startTime > kubectl_1.KUBECTL_DEFAULT_TIMEOUT * 1000) { + throw new exceptions_1.TimeoutError(`Timed out waiting for namespace ${namespace} delete to complete`, { namespace }); + } + } + return {}; + }); +} +exports.cleanupEnvironment = cleanupEnvironment; +function getLoginStatus({ ctx }) { + return __awaiter(this, void 0, void 0, function* () { + const localConfig = yield ctx.localConfigStore.get(); + let currentUsername; + if (localConfig.kubernetes) { + currentUsername = localConfig.kubernetes.username; + } + return !!currentUsername; + }); +} +function login({ ctx, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const entry = logEntry && logEntry.info({ section: "kubernetes", msg: "Logging in..." }); + const localConfig = yield ctx.localConfigStore.get(); + let currentUsername; + let prevUsernames = []; + if (localConfig.kubernetes) { + currentUsername = localConfig.kubernetes.username; + prevUsernames = localConfig.kubernetes["previous-usernames"] || []; + } + if (currentUsername) { + entry && entry.setDone({ + symbol: "info", + msg: `Already logged in as user ${currentUsername}`, + }); + return { loggedIn: true }; + } + const promptName = "username"; + const newUserOption = "Add new user"; + let ans; + const inputPrompt = () => __awaiter(this, void 0, void 0, function* () { + return inquirer.prompt({ + name: promptName, + message: "Enter username", + validate: input => { + try { + Joi.attempt(input.trim(), common_1.joiIdentifier()); + } + catch (err) { + return `Invalid username, please try again\nError: ${err.message}`; + } + return true; + }, + }); + }); + const choicesPrompt = () => __awaiter(this, void 0, void 0, function* () { + return inquirer.prompt({ + name: promptName, + type: "list", + message: "Log in as...", + choices: [...prevUsernames, new inquirer.Separator(), newUserOption], + }); + }); + if (prevUsernames.length > 0) { + ans = (yield choicesPrompt()); + if (ans.username === newUserOption) { + ans = (yield inputPrompt()); + } + } + else { + ans = (yield inputPrompt()); + } + const username = ans.username.trim(); + const newPrevUsernames = lodash_1.uniq([...prevUsernames, username].slice(-MAX_STORED_USERNAMES)); + yield ctx.localConfigStore.set([ + { keyPath: [kubernetes_1.name, "username"], value: username }, + { keyPath: [kubernetes_1.name, "previous-usernames"], value: newPrevUsernames }, + ]); + return { loggedIn: true }; + }); +} +function logout({ ctx, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const entry = logEntry && logEntry.info({ section: "kubernetes", msg: "Logging out..." }); + const localConfig = yield ctx.localConfigStore.get(); + const k8sConfig = localConfig.kubernetes || {}; + if (k8sConfig.username) { + yield ctx.localConfigStore.delete([kubernetes_1.name, "username"]); + entry && entry.setSuccess("Logged out"); + } + else { + entry && entry.setSuccess("Already logged out"); + } + }); +} +function configureSystemServices({ ctx, force, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const provider = ctx.provider; + const sysGarden = yield system_1.getSystemGarden(provider); + const sysCtx = sysGarden.getPluginContext(provider.name); + // TODO: need to add logic here to wait for tiller to be ready + yield helm_1.helm(sysCtx.provider, "init", "--wait", "--service-account", "default", "--upgrade"); + const sysStatus = yield getLocalEnvironmentStatus({ + ctx: sysCtx, + logEntry, + }); + yield prepareLocalEnvironment({ + ctx: sysCtx, + force, + status: sysStatus, + logEntry, + }); + // only deploy services if configured to do so (minikube bundles the required services as addons) + if (!provider.config._systemServices || provider.config._systemServices.length > 0) { + const results = yield sysGarden.actions.deployServices({ + serviceNames: provider.config._systemServices, + }); + const failed = lodash_1.values(results.taskResults).filter(r => !!r.error).length; + if (failed) { + throw new exceptions_1.PluginError(`local-kubernetes: ${failed} errors occurred when configuring environment`, { + results, + }); + } + } + }); +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/kubernetes/init.ts"],"names":[],"mappings":"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","file":"plugins/kubernetes/init.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Bluebird from \"bluebird\"\nimport * as inquirer from \"inquirer\"\nimport * as Joi from \"joi\"\nimport { uniq, every, values } from \"lodash\"\n\nimport { DeploymentError, NotFoundError, TimeoutError, PluginError } from \"../../exceptions\"\nimport {\n  PrepareEnvironmentParams,\n  CleanupEnvironmentParams,\n  GetEnvironmentStatusParams,\n  PluginActionParamsBase,\n} from \"../../types/plugin/params\"\nimport { sleep } from \"../../util/util\"\nimport { joiIdentifier } from \"../../config/common\"\nimport { KubeApi } from \"./api\"\nimport {\n  getAppNamespace,\n  getMetadataNamespace,\n  getAllGardenNamespaces,\n} from \"./namespace\"\nimport { KUBECTL_DEFAULT_TIMEOUT, kubectl } from \"./kubectl\"\nimport { name as providerName } from \"./kubernetes\"\nimport { isSystemGarden, getSystemGarden } from \"./system\"\nimport { PluginContext } from \"../../plugin-context\"\nimport { LogEntry } from \"../../logger/log-entry\"\nimport { helm } from \"./helm\"\n\nconst MAX_STORED_USERNAMES = 5\n\n/**\n * Used by both the remote and local plugin\n */\nasync function prepareNamespaces({ ctx }: GetEnvironmentStatusParams) {\n  const kubeContext = ctx.provider.config.context\n\n  try {\n    // TODO: use API instead of kubectl (I just couldn't find which API call to make)\n    await kubectl(kubeContext).call([\"version\"])\n  } catch (err) {\n    // TODO: catch error properly\n    if (err.detail.output) {\n      throw new DeploymentError(\n        `Unable to connect to Kubernetes cluster. ` +\n        `Please make sure it is running, reachable and that you have the right context configured.`,\n        {\n          kubeContext,\n          kubectlOutput: err.detail.output,\n        },\n      )\n    }\n    throw err\n  }\n\n  await Bluebird.all([\n    getMetadataNamespace(ctx, ctx.provider),\n    getAppNamespace(ctx, ctx.provider),\n  ])\n}\n\nexport async function getRemoteEnvironmentStatus({ ctx }: GetEnvironmentStatusParams) {\n  const loggedIn = await getLoginStatus({ ctx })\n\n  if (!loggedIn) {\n    return {\n      ready: false,\n      needUserInput: true,\n    }\n  }\n\n  await prepareNamespaces({ ctx })\n\n  return {\n    ready: true,\n    needUserInput: false,\n  }\n}\n\nexport async function getLocalEnvironmentStatus({ ctx }: GetEnvironmentStatusParams) {\n  let ready = true\n  let needUserInput = false\n\n  await prepareNamespaces({ ctx })\n\n  // TODO: check if mkcert has been installed\n  // TODO: check if all certs have been generated\n\n  // check if system services are deployed\n  if (!isSystemGarden(ctx.provider)) {\n    const sysGarden = await getSystemGarden(ctx.provider)\n    const sysStatus = await sysGarden.actions.getStatus()\n\n    const systemReady = sysStatus.providers[ctx.provider.config.name].ready &&\n      every(values(sysStatus.services).map(s => s.state === \"ready\"))\n\n    if (!systemReady) {\n      ready = false\n    }\n  }\n\n  return {\n    ready,\n    needUserInput,\n  }\n}\n\nexport async function prepareRemoteEnvironment({ ctx, logEntry }: PrepareEnvironmentParams) {\n  const loggedIn = await getLoginStatus({ ctx, logEntry })\n\n  if (!loggedIn) {\n    await login({ ctx, logEntry })\n  }\n\n  return {}\n}\n\nexport async function prepareLocalEnvironment({ ctx, force, logEntry }: PrepareEnvironmentParams) {\n  // make sure system services are deployed\n  if (!isSystemGarden(ctx.provider)) {\n    await configureSystemServices({ ctx, force, logEntry })\n  }\n\n  // TODO: make sure all certs have been generated\n  return {}\n}\n\nexport async function cleanupEnvironment({ ctx, logEntry }: CleanupEnvironmentParams) {\n  const api = new KubeApi(ctx.provider)\n  const namespace = await getAppNamespace(ctx, ctx.provider)\n  const entry = logEntry && logEntry.info({\n    section: \"kubernetes\",\n    msg: `Deleting namespace ${namespace} (this may take a while)`,\n    status: \"active\",\n  })\n\n  try {\n    // Note: Need to call the delete method with an empty object\n    // TODO: any cast is required until https://github.com/kubernetes-client/javascript/issues/52 is fixed\n    await api.core.deleteNamespace(namespace, <any>{})\n  } catch (err) {\n    entry && entry.setError(err.message)\n    const availableNamespaces = await getAllGardenNamespaces(api)\n    throw new NotFoundError(err, { namespace, availableNamespaces })\n  }\n\n  await logout({ ctx, logEntry })\n\n  // Wait until namespace has been deleted\n  const startTime = new Date().getTime()\n  while (true) {\n    await sleep(2000)\n\n    const nsNames = await getAllGardenNamespaces(api)\n    if (!nsNames.includes(namespace)) {\n      break\n    }\n\n    const now = new Date().getTime()\n    if (now - startTime > KUBECTL_DEFAULT_TIMEOUT * 1000) {\n      throw new TimeoutError(\n        `Timed out waiting for namespace ${namespace} delete to complete`,\n        { namespace },\n      )\n    }\n  }\n\n  return {}\n}\n\nasync function getLoginStatus({ ctx }: PluginActionParamsBase) {\n  const localConfig = await ctx.localConfigStore.get()\n  let currentUsername\n  if (localConfig.kubernetes) {\n    currentUsername = localConfig.kubernetes.username\n  }\n  return !!currentUsername\n}\n\nasync function login({ ctx, logEntry }: PluginActionParamsBase) {\n  const entry = logEntry && logEntry.info({ section: \"kubernetes\", msg: \"Logging in...\" })\n  const localConfig = await ctx.localConfigStore.get()\n\n  let currentUsername\n  let prevUsernames: Array<string> = []\n\n  if (localConfig.kubernetes) {\n    currentUsername = localConfig.kubernetes.username\n    prevUsernames = localConfig.kubernetes[\"previous-usernames\"] || []\n  }\n\n  if (currentUsername) {\n    entry && entry.setDone({\n      symbol: \"info\",\n      msg: `Already logged in as user ${currentUsername}`,\n    })\n\n    return { loggedIn: true }\n  }\n\n  const promptName = \"username\"\n  const newUserOption = \"Add new user\"\n  type Ans = { [promptName]: string }\n  let ans: Ans\n\n  const inputPrompt = async () => {\n    return inquirer.prompt({\n      name: promptName,\n      message: \"Enter username\",\n      validate: input => {\n        try {\n          Joi.attempt(input.trim(), joiIdentifier())\n        } catch (err) {\n          return `Invalid username, please try again\\nError: ${err.message}`\n        }\n        return true\n      },\n    })\n  }\n  const choicesPrompt = async () => {\n    return inquirer.prompt({\n      name: promptName,\n      type: \"list\",\n      message: \"Log in as...\",\n      choices: [...prevUsernames, new inquirer.Separator(), newUserOption],\n    })\n  }\n  if (prevUsernames.length > 0) {\n    ans = await choicesPrompt() as Ans\n    if (ans.username === newUserOption) {\n      ans = await inputPrompt() as Ans\n    }\n  } else {\n    ans = await inputPrompt() as Ans\n  }\n\n  const username = ans.username.trim()\n  const newPrevUsernames = uniq([...prevUsernames, username].slice(-MAX_STORED_USERNAMES))\n\n  await ctx.localConfigStore.set([\n    { keyPath: [providerName, \"username\"], value: username },\n    { keyPath: [providerName, \"previous-usernames\"], value: newPrevUsernames },\n  ])\n\n  return { loggedIn: true }\n}\n\nasync function logout({ ctx, logEntry }: PluginActionParamsBase) {\n  const entry = logEntry && logEntry.info({ section: \"kubernetes\", msg: \"Logging out...\" })\n  const localConfig = await ctx.localConfigStore.get()\n  const k8sConfig = localConfig.kubernetes || {}\n\n  if (k8sConfig.username) {\n    await ctx.localConfigStore.delete([providerName, \"username\"])\n    entry && entry.setSuccess(\"Logged out\")\n  } else {\n    entry && entry.setSuccess(\"Already logged out\")\n  }\n}\n\nasync function configureSystemServices(\n  { ctx, force, logEntry }:\n    { ctx: PluginContext, force: boolean, logEntry?: LogEntry },\n) {\n  const provider = ctx.provider\n  const sysGarden = await getSystemGarden(provider)\n  const sysCtx = sysGarden.getPluginContext(provider.name)\n\n  // TODO: need to add logic here to wait for tiller to be ready\n  await helm(sysCtx.provider,\n    \"init\", \"--wait\",\n    \"--service-account\", \"default\",\n    \"--upgrade\",\n  )\n\n  const sysStatus = await getLocalEnvironmentStatus({\n    ctx: sysCtx,\n    logEntry,\n  })\n\n  await prepareLocalEnvironment({\n    ctx: sysCtx,\n    force,\n    status: sysStatus,\n    logEntry,\n  })\n\n  // only deploy services if configured to do so (minikube bundles the required services as addons)\n  if (!provider.config._systemServices || provider.config._systemServices.length > 0) {\n    const results = await sysGarden.actions.deployServices({\n      serviceNames: provider.config._systemServices,\n    })\n\n    const failed = values(results.taskResults).filter(r => !!r.error).length\n\n    if (failed) {\n      throw new PluginError(`local-kubernetes: ${failed} errors occurred when configuring environment`, {\n        results,\n      })\n    }\n  }\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/kubectl.d.ts b/garden-service/build/plugins/kubernetes/kubectl.d.ts new file mode 100644 index 00000000000..f0e80de37bd --- /dev/null +++ b/garden-service/build/plugins/kubernetes/kubectl.d.ts @@ -0,0 +1,51 @@ +/// +import { ChildProcess } from "child_process"; +export interface KubectlParams { + data?: Buffer; + ignoreError?: boolean; + silent?: boolean; + timeout?: number; + tty?: boolean; +} +export interface KubectlOutput { + code: number; + output: string; + stdout?: string; + stderr?: string; +} +export interface ApplyOptions { + dryRun?: boolean; + force?: boolean; + pruneSelector?: string; + namespace?: string; +} +export declare const KUBECTL_DEFAULT_TIMEOUT = 300; +export declare class Kubectl { + context?: string; + namespace?: string; + configPath?: string; + constructor({ context, namespace, configPath }: { + context: string; + namespace?: string; + configPath?: string; + }); + call(args: string[], { data, ignoreError, silent, timeout }?: KubectlParams): Promise; + json(args: string[], opts?: KubectlParams): Promise; + tty(args: string[], opts?: KubectlParams): Promise; + spawn(args: string[]): ChildProcess; + private getExececutable; + private prepareArgs; +} +export declare function kubectl(context: string, namespace?: string): Kubectl; +export declare function apply(context: string, obj: object, params: ApplyOptions): Promise; +export declare function applyMany(context: string, objects: object[], { dryRun, force, namespace, pruneSelector }?: ApplyOptions): Promise; +export interface DeleteObjectsParams { + context: string; + namespace: string; + labelKey: string; + labelValue: string; + objectTypes: string[]; + includeUninitialized?: boolean; +} +export declare function deleteObjectsByLabel({ context, namespace, labelKey, labelValue, objectTypes, includeUninitialized, }: DeleteObjectsParams): Promise; +//# sourceMappingURL=kubectl.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/kubectl.js b/garden-service/build/plugins/kubernetes/kubectl.js new file mode 100644 index 00000000000..8b356905d49 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/kubectl.js @@ -0,0 +1,176 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const chalk_1 = require("chalk"); +const child_process_1 = require("child_process"); +const lodash_1 = require("lodash"); +const util_1 = require("../../util/util"); +const exceptions_1 = require("../../exceptions"); +const logger_1 = require("../../logger/logger"); +const os_1 = require("os"); +const hasAnsi = require("has-ansi"); +exports.KUBECTL_DEFAULT_TIMEOUT = 300; +class Kubectl { + // TODO: namespace should always be required + constructor({ context, namespace, configPath }) { + this.context = context; + this.namespace = namespace; + this.configPath = configPath; + } + call(args, { data, ignoreError = false, silent = true, timeout = exports.KUBECTL_DEFAULT_TIMEOUT } = {}) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: use the spawn helper from index.ts + const logger = logger_1.getLogger(); + const out = { + code: 0, + output: "", + stdout: "", + stderr: "", + }; + const preparedArgs = this.prepareArgs(args); + const proc = child_process_1.spawn(this.getExececutable(), preparedArgs); + proc.stdout.on("data", (s) => { + if (!silent) { + const str = s.toString(); + logger.info(hasAnsi(str) ? str : chalk_1.default.white(str)); + } + out.output += s; + out.stdout += s; + }); + proc.stderr.on("data", (s) => { + if (!silent) { + const str = s.toString(); + logger.info(hasAnsi(str) ? str : chalk_1.default.white(str)); + } + out.output += s; + out.stderr += s; + }); + if (data) { + proc.stdin.end(data); + } + return new Promise((resolve, reject) => { + let _timeout; + const _reject = (msg) => { + const dataStr = data ? data.toString() : null; + const details = lodash_1.extend({ args, preparedArgs, msg, data: dataStr }, out); + const err = new exceptions_1.RuntimeError(`Failed running 'kubectl ${preparedArgs.join(" ")}': ${out.output}`, details); + reject(err); + }; + if (timeout > 0) { + _timeout = setTimeout(() => { + proc.kill("SIGKILL"); + _reject(`kubectl timed out after ${timeout} seconds.`); + }, timeout * 1000); + } + proc.on("close", (code) => { + _timeout && clearTimeout(_timeout); + out.code = code; + if (code === 0 || ignoreError) { + resolve(out); + } + else { + _reject("Process exited with code " + code); + } + }); + }); + }); + } + json(args, opts = {}) { + return __awaiter(this, void 0, void 0, function* () { + if (!args.includes("--output=json")) { + args.push("--output=json"); + } + const result = yield this.call(args, opts); + return JSON.parse(result.output); + }); + } + tty(args, opts = {}) { + return __awaiter(this, void 0, void 0, function* () { + return util_1.spawnPty(this.getExececutable(), this.prepareArgs(args), opts); + }); + } + spawn(args) { + return child_process_1.spawn(this.getExececutable(), this.prepareArgs(args)); + } + getExececutable() { + // workaround for https://github.com/Microsoft/node-pty/issues/109 + return os_1.platform() === "win32" ? "kubectl.exe" : "kubectl"; + } + prepareArgs(args) { + const ops = []; + if (this.namespace) { + ops.push(`--namespace=${this.namespace}`); + } + if (this.context) { + ops.push(`--context=${this.context}`); + } + if (this.configPath) { + ops.push(`--kubeconfig=${this.configPath}`); + } + return ops.concat(args); + } +} +exports.Kubectl = Kubectl; +function kubectl(context, namespace) { + return new Kubectl({ context, namespace }); +} +exports.kubectl = kubectl; +function apply(context, obj, params) { + return __awaiter(this, void 0, void 0, function* () { + return applyMany(context, [obj], params); + }); +} +exports.apply = apply; +function applyMany(context, objects, { dryRun = false, force = false, namespace, pruneSelector } = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = Buffer.from(util_1.encodeYamlMulti(objects)); + let args = ["apply"]; + dryRun && args.push("--dry-run"); + force && args.push("--force"); + pruneSelector && args.push("--prune", "--selector", pruneSelector); + args.push("--output=json", "-f", "-"); + const result = yield kubectl(context, namespace).call(args, { data }); + try { + return JSON.parse(result.output); + } + catch (_) { + return result.output; + } + }); +} +exports.applyMany = applyMany; +function deleteObjectsByLabel({ context, namespace, labelKey, labelValue, objectTypes, includeUninitialized = false, }) { + return __awaiter(this, void 0, void 0, function* () { + let args = [ + "delete", + objectTypes.join(","), + "-l", + `${labelKey}=${labelValue}`, + ]; + includeUninitialized && args.push("--include-uninitialized"); + const result = yield kubectl(context, namespace).call(args); + try { + return JSON.parse(result.output); + } + catch (_) { + return result.output; + } + }); +} +exports.deleteObjectsByLabel = deleteObjectsByLabel; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/kubernetes/kubectl.ts"],"names":[],"mappings":"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","file":"plugins/kubernetes/kubectl.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport chalk from \"chalk\"\nimport { ChildProcess, spawn } from \"child_process\"\nimport { extend } from \"lodash\"\nimport { encodeYamlMulti, spawnPty } from \"../../util/util\"\nimport { RuntimeError } from \"../../exceptions\"\nimport { getLogger } from \"../../logger/logger\"\nimport { platform } from \"os\"\nimport hasAnsi = require(\"has-ansi\")\n\nexport interface KubectlParams {\n  data?: Buffer,\n  ignoreError?: boolean,\n  silent?: boolean,\n  timeout?: number,\n  tty?: boolean,\n}\n\nexport interface KubectlOutput {\n  code: number,\n  output: string,\n  stdout?: string,\n  stderr?: string,\n}\n\nexport interface ApplyOptions {\n  dryRun?: boolean,\n  force?: boolean,\n  pruneSelector?: string,\n  namespace?: string,\n}\n\nexport const KUBECTL_DEFAULT_TIMEOUT = 300\n\nexport class Kubectl {\n  public context?: string\n  public namespace?: string\n  public configPath?: string\n\n  // TODO: namespace should always be required\n  constructor({ context, namespace, configPath }: { context: string, namespace?: string, configPath?: string }) {\n    this.context = context\n    this.namespace = namespace\n    this.configPath = configPath\n  }\n\n  async call(\n    args: string[],\n    { data, ignoreError = false, silent = true, timeout = KUBECTL_DEFAULT_TIMEOUT }: KubectlParams = {},\n  ): Promise<KubectlOutput> {\n    // TODO: use the spawn helper from index.ts\n    const logger = getLogger()\n    const out: KubectlOutput = {\n      code: 0,\n      output: \"\",\n      stdout: \"\",\n      stderr: \"\",\n    }\n\n    const preparedArgs = this.prepareArgs(args)\n    const proc = spawn(this.getExececutable(), preparedArgs)\n\n    proc.stdout.on(\"data\", (s) => {\n      if (!silent) {\n        const str = s.toString()\n        logger.info(hasAnsi(str) ? str : chalk.white(str))\n      }\n      out.output += s\n      out.stdout! += s\n    })\n\n    proc.stderr.on(\"data\", (s) => {\n      if (!silent) {\n        const str = s.toString()\n        logger.info(hasAnsi(str) ? str : chalk.white(str))\n      }\n      out.output += s\n      out.stderr! += s\n    })\n\n    if (data) {\n      proc.stdin.end(data)\n    }\n\n    return new Promise<KubectlOutput>((resolve, reject) => {\n      let _timeout\n\n      const _reject = (msg: string) => {\n        const dataStr = data ? data.toString() : null\n        const details = extend({ args, preparedArgs, msg, data: dataStr }, <any>out)\n\n        const err = new RuntimeError(\n          `Failed running 'kubectl ${preparedArgs.join(\" \")}': ${out.output}`,\n          details,\n        )\n        reject(err)\n      }\n\n      if (timeout > 0) {\n        _timeout = setTimeout(() => {\n          proc.kill(\"SIGKILL\")\n          _reject(`kubectl timed out after ${timeout} seconds.`)\n        }, timeout * 1000)\n      }\n\n      proc.on(\"close\", (code) => {\n        _timeout && clearTimeout(_timeout)\n        out.code = code\n\n        if (code === 0 || ignoreError) {\n          resolve(out)\n        } else {\n          _reject(\"Process exited with code \" + code)\n        }\n      })\n    })\n  }\n\n  async json(args: string[], opts: KubectlParams = {}): Promise<KubectlOutput> {\n    if (!args.includes(\"--output=json\")) {\n      args.push(\"--output=json\")\n    }\n\n    const result = await this.call(args, opts)\n\n    return JSON.parse(result.output)\n  }\n\n  async tty(args: string[], opts: KubectlParams = {}): Promise<KubectlOutput> {\n    return spawnPty(this.getExececutable(), this.prepareArgs(args), opts)\n  }\n\n  spawn(args: string[]): ChildProcess {\n    return spawn(this.getExececutable(), this.prepareArgs(args))\n  }\n\n  private getExececutable() {\n    // workaround for https://github.com/Microsoft/node-pty/issues/109\n    return platform() === \"win32\" ? \"kubectl.exe\" : \"kubectl\"\n  }\n\n  private prepareArgs(args: string[]) {\n    const ops: string[] = []\n\n    if (this.namespace) {\n      ops.push(`--namespace=${this.namespace}`)\n    }\n\n    if (this.context) {\n      ops.push(`--context=${this.context}`)\n    }\n\n    if (this.configPath) {\n      ops.push(`--kubeconfig=${this.configPath}`)\n    }\n\n    return ops.concat(args)\n  }\n}\n\nexport function kubectl(context: string, namespace?: string) {\n  return new Kubectl({ context, namespace })\n}\n\nexport async function apply(context: string, obj: object, params: ApplyOptions) {\n  return applyMany(context, [obj], params)\n}\n\nexport async function applyMany(\n  context: string, objects: object[],\n  { dryRun = false, force = false, namespace, pruneSelector }: ApplyOptions = {},\n) {\n  const data = Buffer.from(encodeYamlMulti(objects))\n\n  let args = [\"apply\"]\n  dryRun && args.push(\"--dry-run\")\n  force && args.push(\"--force\")\n  pruneSelector && args.push(\"--prune\", \"--selector\", pruneSelector)\n  args.push(\"--output=json\", \"-f\", \"-\")\n\n  const result = await kubectl(context, namespace).call(args, { data })\n\n  try {\n    return JSON.parse(result.output)\n  } catch (_) {\n    return result.output\n  }\n}\n\nexport interface DeleteObjectsParams {\n  context: string,\n  namespace: string,\n  labelKey: string,\n  labelValue: string,\n  objectTypes: string[],\n  includeUninitialized?: boolean,\n}\n\nexport async function deleteObjectsByLabel(\n  {\n    context,\n    namespace,\n    labelKey,\n    labelValue,\n    objectTypes,\n    includeUninitialized = false,\n  }: DeleteObjectsParams) {\n\n  let args = [\n    \"delete\",\n    objectTypes.join(\",\"),\n    \"-l\",\n    `${labelKey}=${labelValue}`,\n  ]\n\n  includeUninitialized && args.push(\"--include-uninitialized\")\n\n  const result = await kubectl(context, namespace).call(args)\n\n  try {\n    return JSON.parse(result.output)\n  } catch (_) {\n    return result.output\n  }\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/kubernetes.d.ts b/garden-service/build/plugins/kubernetes/kubernetes.d.ts new file mode 100644 index 00000000000..7ca12366c3a --- /dev/null +++ b/garden-service/build/plugins/kubernetes/kubernetes.d.ts @@ -0,0 +1,36 @@ +import * as Joi from "joi"; +import { GardenPlugin } from "../../types/plugin/plugin"; +import { Provider, ProviderConfig } from "../../config/project"; +import { ContainerRegistryConfig } from "../container"; +export declare const name = "kubernetes"; +export interface SecretRef { + name: string; + namespace: string; +} +export interface IngressTlsCertificate { + name: string; + hostnames?: string[]; + secretRef: SecretRef; +} +export interface KubernetesBaseConfig extends ProviderConfig { + context: string; + defaultHostname?: string; + defaultUsername?: string; + forceSsl: boolean; + imagePullSecrets: SecretRef[]; + ingressHttpPort: number; + ingressHttpsPort: number; + ingressClass: string; + namespace?: string; + tlsCertificates: IngressTlsCertificate[]; +} +export interface KubernetesConfig extends KubernetesBaseConfig { + deploymentRegistry: ContainerRegistryConfig; +} +export declare type KubernetesProvider = Provider; +export declare const k8sContextSchema: Joi.StringSchema; +export declare const kubernetesConfigBase: Joi.ObjectSchema; +export declare function gardenPlugin({ config }: { + config: KubernetesConfig; +}): GardenPlugin; +//# sourceMappingURL=kubernetes.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/kubernetes.js b/garden-service/build/plugins/kubernetes/kubernetes.js new file mode 100644 index 00000000000..2a7a199ac05 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/kubernetes.js @@ -0,0 +1,128 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const dedent = require("dedent"); +const common_1 = require("../../config/common"); +const project_1 = require("../../config/project"); +const actions_1 = require("./actions"); +const deployment_1 = require("./deployment"); +const helm_1 = require("./helm"); +const secrets_1 = require("./secrets"); +const container_1 = require("../container"); +const init_1 = require("./init"); +exports.name = "kubernetes"; +exports.k8sContextSchema = Joi.string() + .required() + .description("The kubectl context to use to connect to the Kubernetes cluster.") + .example("my-dev-context"); +const secretRef = Joi.object() + .keys({ + name: common_1.joiIdentifier() + .required() + .description("The name of the Kubernetes secret.") + .example("my-secret"), + namespace: common_1.joiIdentifier() + .default("default") + .description("The namespace where the secret is stored. " + + "If necessary, the secret may be copied to the appropriate namespace before use."), +}) + .description("Reference to a Kubernetes secret."); +const imagePullSecretsSchema = common_1.joiArray(secretRef) + .description(dedent ` + References to \`docker-registry\` secrets to use for authenticating with remote registries when pulling + images. This is necessary if you reference private images in your module configuration, and is required + when configuring a remote Kubernetes environment. + `); +const tlsCertificateSchema = Joi.object() + .keys({ + name: common_1.joiIdentifier() + .required() + .description("A unique identifier for this certificate.") + .example("www") + .example("wildcard"), + hostnames: Joi.array().items(Joi.string().hostname()) + .description("A list of hostnames that this certificate should be used for. " + + "If you don't specify these, they will be automatically read from the certificate.") + .example(["www.mydomain.com"]), + secretRef: secretRef + .description("A reference to the Kubernetes secret that contains the TLS certificate and key for the domain.") + .example({ name: "my-tls-secret", namespace: "default" }), +}); +exports.kubernetesConfigBase = project_1.providerConfigBaseSchema + .keys({ + defaultHostname: Joi.string() + .description("A default hostname to use when no hostname is explicitly configured for a service.") + .example("api.mydomain.com"), + defaultUsername: common_1.joiIdentifier() + .description("Set a default username (used for namespacing within a cluster)."), + forceSsl: Joi.boolean() + .default(false) + .description("Require SSL on all services. If set to true, an error is raised when no certificate " + + "is available for a configured hostname."), + imagePullSecrets: imagePullSecretsSchema, + namespace: Joi.string() + .description("Specify which namespace to deploy services to (auto-generated by default). " + + "Note that the framework generates other namespaces as well with this name as a prefix."), + tlsCertificates: common_1.joiArray(tlsCertificateSchema) + .unique("name") + .description("One or more certificates to use for ingress."), +}); +const configSchema = exports.kubernetesConfigBase + .keys({ + context: exports.k8sContextSchema + .required(), + deploymentRegistry: container_1.containerRegistryConfigSchema, + ingressClass: Joi.string() + .default("nginx") + .description(dedent ` + The ingress class to use on configured Ingresses when deploying services. **Note that Garden + currently only supports the nginx ingress controller.** + `), + ingressHttpPort: Joi.number() + .default(80) + .description("The external HTTP port of the cluster's ingress controller."), + ingressHttpsPort: Joi.number() + .default(443) + .description("The external HTTPS port of the cluster's ingress controller."), + _system: Joi.any().meta({ internal: true }), +}); +function gardenPlugin({ config }) { + config = common_1.validate(config, configSchema, { context: "kubernetes provider config" }); + return { + config, + actions: { + getEnvironmentStatus: init_1.getRemoteEnvironmentStatus, + prepareEnvironment: init_1.prepareRemoteEnvironment, + cleanupEnvironment: init_1.cleanupEnvironment, + getSecret: secrets_1.getSecret, + setSecret: secrets_1.setSecret, + deleteSecret: secrets_1.deleteSecret, + }, + moduleActions: { + container: { + getServiceStatus: deployment_1.getContainerServiceStatus, + deployService: deployment_1.deployContainerService, + deleteService: actions_1.deleteService, + getServiceOutputs: actions_1.getServiceOutputs, + execInService: actions_1.execInService, + pushModule: deployment_1.pushModule, + runModule: actions_1.runModule, + testModule: actions_1.testModule, + runService: actions_1.runService, + getTestResult: actions_1.getTestResult, + getServiceLogs: actions_1.getServiceLogs, + }, + helm: helm_1.helmHandlers, + }, + }; +} +exports.gardenPlugin = gardenPlugin; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/kubernetes/kubernetes.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAEH,2BAA0B;AAC1B,iCAAiC;AAEjC,gDAI4B;AAE5B,kDAAyF;AACzF,uCASkB;AAClB,6CAA4F;AAC5F,iCAAqC;AACrC,uCAA8D;AAC9D,4CAAqF;AACrF,iCAAiG;AAEpF,QAAA,IAAI,GAAG,YAAY,CAAA;AAgCnB,QAAA,gBAAgB,GAAG,GAAG,CAAC,MAAM,EAAE;KACzC,QAAQ,EAAE;KACV,WAAW,CAAC,kEAAkE,CAAC;KAC/E,OAAO,CAAC,gBAAgB,CAAC,CAAA;AAE5B,MAAM,SAAS,GAAG,GAAG,CAAC,MAAM,EAAE;KAC3B,IAAI,CAAC;IACJ,IAAI,EAAE,sBAAa,EAAE;SAClB,QAAQ,EAAE;SACV,WAAW,CAAC,oCAAoC,CAAC;SACjD,OAAO,CAAC,WAAW,CAAC;IACvB,SAAS,EAAE,sBAAa,EAAE;SACvB,OAAO,CAAC,SAAS,CAAC;SAClB,WAAW,CACV,4CAA4C;QAC5C,iFAAiF,CAClF;CACJ,CAAC;KACD,WAAW,CAAC,mCAAmC,CAAC,CAAA;AAEnD,MAAM,sBAAsB,GAAG,iBAAQ,CAAC,SAAS,CAAC;KAC/C,WAAW,CAAC,MAAM,CAAA;;;;GAIlB,CAAC,CAAA;AAEJ,MAAM,oBAAoB,GAAG,GAAG,CAAC,MAAM,EAAE;KACtC,IAAI,CAAC;IACJ,IAAI,EAAE,sBAAa,EAAE;SAClB,QAAQ,EAAE;SACV,WAAW,CAAC,2CAA2C,CAAC;SACxD,OAAO,CAAC,KAAK,CAAC;SACd,OAAO,CAAC,UAAU,CAAC;IACtB,SAAS,EAAE,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC;SAClD,WAAW,CACV,gEAAgE;QAChE,mFAAmF,CACpF;SACA,OAAO,CAAC,CAAC,kBAAkB,CAAC,CAAC;IAChC,SAAS,EAAE,SAAS;SACjB,WAAW,CAAC,gGAAgG,CAAC;SAC7G,OAAO,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC;CAC5D,CAAC,CAAA;AAES,QAAA,oBAAoB,GAAG,kCAAwB;KACzD,IAAI,CAAC;IACJ,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE;SAC1B,WAAW,CAAC,oFAAoF,CAAC;SACjG,OAAO,CAAC,kBAAkB,CAAC;IAC9B,eAAe,EAAE,sBAAa,EAAE;SAC7B,WAAW,CAAC,iEAAiE,CAAC;IACjF,QAAQ,EAAE,GAAG,CAAC,OAAO,EAAE;SACpB,OAAO,CAAC,KAAK,CAAC;SACd,WAAW,CACV,sFAAsF;QACtF,yCAAyC,CAC1C;IACH,gBAAgB,EAAE,sBAAsB;IACxC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE;SACpB,WAAW,CACV,6EAA6E;QAC7E,wFAAwF,CACzF;IACH,eAAe,EAAE,iBAAQ,CAAC,oBAAoB,CAAC;SAC5C,MAAM,CAAC,MAAM,CAAC;SACd,WAAW,CAAC,8CAA8C,CAAC;CAC/D,CAAC,CAAA;AAEJ,MAAM,YAAY,GAAG,4BAAoB;KACtC,IAAI,CAAC;IACJ,OAAO,EAAE,wBAAgB;SACtB,QAAQ,EAAE;IACb,kBAAkB,EAAE,yCAA6B;IACjD,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE;SACvB,OAAO,CAAC,OAAO,CAAC;SAChB,WAAW,CAAC,MAAM,CAAA;;;OAGlB,CAAC;IACJ,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE;SAC1B,OAAO,CAAC,EAAE,CAAC;SACX,WAAW,CAAC,6DAA6D,CAAC;IAC7E,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE;SAC3B,OAAO,CAAC,GAAG,CAAC;SACZ,WAAW,CAAC,8DAA8D,CAAC;IAC9E,OAAO,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;CAC5C,CAAC,CAAA;AAEJ,SAAgB,YAAY,CAAC,EAAE,MAAM,EAAgC;IACnE,MAAM,GAAG,iBAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,OAAO,EAAE,4BAA4B,EAAE,CAAC,CAAA;IAElF,OAAO;QACL,MAAM;QACN,OAAO,EAAE;YACP,oBAAoB,EAAE,iCAA0B;YAChD,kBAAkB,EAAE,+BAAwB;YAC5C,kBAAkB,EAAlB,yBAAkB;YAClB,SAAS,EAAT,mBAAS;YACT,SAAS,EAAT,mBAAS;YACT,YAAY,EAAZ,sBAAY;SACb;QACD,aAAa,EAAE;YACb,SAAS,EAAE;gBACT,gBAAgB,EAAE,sCAAyB;gBAC3C,aAAa,EAAE,mCAAsB;gBACrC,aAAa,EAAb,uBAAa;gBACb,iBAAiB,EAAjB,2BAAiB;gBACjB,aAAa,EAAb,uBAAa;gBACb,UAAU,EAAV,uBAAU;gBACV,SAAS,EAAT,mBAAS;gBACT,UAAU,EAAV,oBAAU;gBACV,UAAU,EAAV,oBAAU;gBACV,aAAa,EAAb,uBAAa;gBACb,cAAc,EAAd,wBAAc;aACf;YACD,IAAI,EAAE,mBAAY;SACnB;KACF,CAAA;AACH,CAAC;AA9BD,oCA8BC","file":"plugins/kubernetes/kubernetes.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Joi from \"joi\"\nimport dedent = require(\"dedent\")\n\nimport {\n  joiArray,\n  joiIdentifier,\n  validate,\n} from \"../../config/common\"\nimport { GardenPlugin } from \"../../types/plugin/plugin\"\nimport { Provider, providerConfigBaseSchema, ProviderConfig } from \"../../config/project\"\nimport {\n  deleteService,\n  execInService,\n  getServiceLogs,\n  getServiceOutputs,\n  getTestResult,\n  testModule,\n  runModule,\n  runService,\n} from \"./actions\"\nimport { deployContainerService, getContainerServiceStatus, pushModule } from \"./deployment\"\nimport { helmHandlers } from \"./helm\"\nimport { getSecret, setSecret, deleteSecret } from \"./secrets\"\nimport { containerRegistryConfigSchema, ContainerRegistryConfig } from \"../container\"\nimport { getRemoteEnvironmentStatus, prepareRemoteEnvironment, cleanupEnvironment } from \"./init\"\n\nexport const name = \"kubernetes\"\n\nexport interface SecretRef {\n  name: string\n  namespace: string\n}\n\nexport interface IngressTlsCertificate {\n  name: string\n  hostnames?: string[]\n  secretRef: SecretRef\n}\n\nexport interface KubernetesBaseConfig extends ProviderConfig {\n  context: string\n  defaultHostname?: string\n  defaultUsername?: string\n  forceSsl: boolean\n  imagePullSecrets: SecretRef[]\n  ingressHttpPort: number\n  ingressHttpsPort: number\n  ingressClass: string\n  namespace?: string\n  tlsCertificates: IngressTlsCertificate[]\n}\n\nexport interface KubernetesConfig extends KubernetesBaseConfig {\n  deploymentRegistry: ContainerRegistryConfig\n}\n\nexport type KubernetesProvider = Provider<KubernetesConfig>\n\nexport const k8sContextSchema = Joi.string()\n  .required()\n  .description(\"The kubectl context to use to connect to the Kubernetes cluster.\")\n  .example(\"my-dev-context\")\n\nconst secretRef = Joi.object()\n  .keys({\n    name: joiIdentifier()\n      .required()\n      .description(\"The name of the Kubernetes secret.\")\n      .example(\"my-secret\"),\n    namespace: joiIdentifier()\n      .default(\"default\")\n      .description(\n        \"The namespace where the secret is stored. \" +\n        \"If necessary, the secret may be copied to the appropriate namespace before use.\",\n      ),\n  })\n  .description(\"Reference to a Kubernetes secret.\")\n\nconst imagePullSecretsSchema = joiArray(secretRef)\n  .description(dedent`\n    References to \\`docker-registry\\` secrets to use for authenticating with remote registries when pulling\n    images. This is necessary if you reference private images in your module configuration, and is required\n    when configuring a remote Kubernetes environment.\n  `)\n\nconst tlsCertificateSchema = Joi.object()\n  .keys({\n    name: joiIdentifier()\n      .required()\n      .description(\"A unique identifier for this certificate.\")\n      .example(\"www\")\n      .example(\"wildcard\"),\n    hostnames: Joi.array().items(Joi.string().hostname())\n      .description(\n        \"A list of hostnames that this certificate should be used for. \" +\n        \"If you don't specify these, they will be automatically read from the certificate.\",\n      )\n      .example([\"www.mydomain.com\"]),\n    secretRef: secretRef\n      .description(\"A reference to the Kubernetes secret that contains the TLS certificate and key for the domain.\")\n      .example({ name: \"my-tls-secret\", namespace: \"default\" }),\n  })\n\nexport const kubernetesConfigBase = providerConfigBaseSchema\n  .keys({\n    defaultHostname: Joi.string()\n      .description(\"A default hostname to use when no hostname is explicitly configured for a service.\")\n      .example(\"api.mydomain.com\"),\n    defaultUsername: joiIdentifier()\n      .description(\"Set a default username (used for namespacing within a cluster).\"),\n    forceSsl: Joi.boolean()\n      .default(false)\n      .description(\n        \"Require SSL on all services. If set to true, an error is raised when no certificate \" +\n        \"is available for a configured hostname.\",\n      ),\n    imagePullSecrets: imagePullSecretsSchema,\n    namespace: Joi.string()\n      .description(\n        \"Specify which namespace to deploy services to (auto-generated by default). \" +\n        \"Note that the framework generates other namespaces as well with this name as a prefix.\",\n      ),\n    tlsCertificates: joiArray(tlsCertificateSchema)\n      .unique(\"name\")\n      .description(\"One or more certificates to use for ingress.\"),\n  })\n\nconst configSchema = kubernetesConfigBase\n  .keys({\n    context: k8sContextSchema\n      .required(),\n    deploymentRegistry: containerRegistryConfigSchema,\n    ingressClass: Joi.string()\n      .default(\"nginx\")\n      .description(dedent`\n        The ingress class to use on configured Ingresses when deploying services. **Note that Garden\n        currently only supports the nginx ingress controller.**\n      `),\n    ingressHttpPort: Joi.number()\n      .default(80)\n      .description(\"The external HTTP port of the cluster's ingress controller.\"),\n    ingressHttpsPort: Joi.number()\n      .default(443)\n      .description(\"The external HTTPS port of the cluster's ingress controller.\"),\n    _system: Joi.any().meta({ internal: true }),\n  })\n\nexport function gardenPlugin({ config }: { config: KubernetesConfig }): GardenPlugin {\n  config = validate(config, configSchema, { context: \"kubernetes provider config\" })\n\n  return {\n    config,\n    actions: {\n      getEnvironmentStatus: getRemoteEnvironmentStatus,\n      prepareEnvironment: prepareRemoteEnvironment,\n      cleanupEnvironment,\n      getSecret,\n      setSecret,\n      deleteSecret,\n    },\n    moduleActions: {\n      container: {\n        getServiceStatus: getContainerServiceStatus,\n        deployService: deployContainerService,\n        deleteService,\n        getServiceOutputs,\n        execInService,\n        pushModule,\n        runModule,\n        testModule,\n        runService,\n        getTestResult,\n        getServiceLogs,\n      },\n      helm: helmHandlers,\n    },\n  }\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/local.d.ts b/garden-service/build/plugins/kubernetes/local.d.ts new file mode 100644 index 00000000000..ed7517403f7 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/local.d.ts @@ -0,0 +1,13 @@ +import { GardenPlugin } from "../../types/plugin/plugin"; +import { KubernetesBaseConfig } from "./kubernetes"; +export interface LocalKubernetesConfig extends KubernetesBaseConfig { + _system?: Symbol; + _systemServices?: string[]; +} +export declare const name = "local-kubernetes"; +export declare function gardenPlugin({ projectName, config, logEntry }: { + projectName: any; + config: any; + logEntry: any; +}): Promise; +//# sourceMappingURL=local.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/local.js b/garden-service/build/plugins/kubernetes/local.js new file mode 100644 index 00000000000..9f1bd8f72f8 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/local.js @@ -0,0 +1,147 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const execa = require("execa"); +const js_yaml_1 = require("js-yaml"); +const Joi = require("joi"); +const path_1 = require("path"); +const common_1 = require("../../config/common"); +const kubernetes_1 = require("./kubernetes"); +const fs_extra_1 = require("fs-extra"); +const os_1 = require("os"); +const init_1 = require("./init"); +// TODO: split this into separate plugins to handle Docker for Mac and Minikube +// note: this is in order of preference, in case neither is set as the current kubectl context +// and none is explicitly configured in the garden.yml +const supportedContexts = ["docker-for-desktop", "minikube"]; +const kubeConfigPath = path_1.join(os_1.homedir(), ".kube", "config"); +function getKubeConfig() { + return __awaiter(this, void 0, void 0, function* () { + try { + return js_yaml_1.safeLoad((yield fs_extra_1.readFile(kubeConfigPath)).toString()); + } + catch (_a) { + return {}; + } + }); +} +/** + * Automatically set docker environment variables for minikube + * TODO: it would be better to explicitly provide those to docker instead of using process.env + */ +function setMinikubeDockerEnv() { + return __awaiter(this, void 0, void 0, function* () { + const minikubeEnv = yield execa.stdout("minikube", ["docker-env", "--shell=bash"]); + for (const line of minikubeEnv.split("\n")) { + const matched = line.match(/^export (\w+)="(.+)"$/); + if (matched) { + process.env[matched[1]] = matched[2]; + } + } + }); +} +const configSchema = kubernetes_1.kubernetesConfigBase + .keys({ + ingressHostname: Joi.string() + .description("The hostname of the cluster's ingress controller."), + _system: Joi.any().meta({ internal: true }), + _systemServices: Joi.array().items(Joi.string()) + .meta({ internal: true }) + .description("The system services which should be automatically deployed to the cluster."), +}) + .description("The provider configuration for the local-kubernetes plugin."); +exports.name = "local-kubernetes"; +function gardenPlugin({ projectName, config, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + config = common_1.validate(config, configSchema, { context: "local-kubernetes provider config" }); + let context = config.context; + let defaultHostname = config.defaultHostname; + let systemServices; + if (!context) { + // automatically detect supported kubectl context if not explicitly configured + const kubeConfig = yield getKubeConfig(); + const currentContext = kubeConfig["current-context"]; + if (currentContext && supportedContexts.includes(currentContext)) { + // prefer current context if set and supported + context = currentContext; + logEntry.debug({ section: exports.name, msg: `Using current context: ${context}` }); + } + else if (kubeConfig.contexts) { + const availableContexts = kubeConfig.contexts.map(c => c.name); + for (const supportedContext of supportedContexts) { + if (availableContexts.includes(supportedContext)) { + context = supportedContext; + logEntry.debug({ section: exports.name, msg: `Using detected context: ${context}` }); + break; + } + } + } + } + if (!context) { + context = supportedContexts[0]; + logEntry.debug({ section: exports.name, msg: `No kubectl context auto-detected, using default: ${context}` }); + } + if (context === "minikube") { + yield execa("minikube", ["config", "set", "WantUpdateNotification", "false"]); + if (!defaultHostname) { + // use the nip.io service to give a hostname to the instance, if none is explicitly configured + const minikubeIp = yield execa.stdout("minikube", ["ip"]); + defaultHostname = `${projectName}.${minikubeIp}.nip.io`; + } + yield Promise.all([ + // TODO: wait for ingress addon to be ready, if it was previously disabled + execa("minikube", ["addons", "enable", "ingress"]), + setMinikubeDockerEnv(), + ]); + systemServices = []; + } + else { + if (!defaultHostname) { + defaultHostname = `${projectName}.local.app.garden`; + } + } + const k8sConfig = { + name: config.name, + context, + defaultHostname, + defaultUsername: "default", + deploymentRegistry: { + hostname: "foo.garden", + namespace: "_", + }, + forceSsl: false, + imagePullSecrets: config.imagePullSecrets, + ingressHttpPort: 80, + ingressHttpsPort: 443, + ingressClass: "nginx", + tlsCertificates: config.tlsCertificates, + // TODO: support SSL on local deployments + _system: config._system, + _systemServices: systemServices, + }; + const plugin = kubernetes_1.gardenPlugin({ config: k8sConfig }); + // override the environment configuration steps + plugin.actions.getEnvironmentStatus = init_1.getLocalEnvironmentStatus; + plugin.actions.prepareEnvironment = init_1.prepareLocalEnvironment; + // no need to push before deploying locally + delete plugin.moduleActions.container.pushModule; + return plugin; + }); +} +exports.gardenPlugin = gardenPlugin; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/kubernetes/local.ts"],"names":[],"mappings":"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","file":"plugins/kubernetes/local.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as execa from \"execa\"\nimport { safeLoad } from \"js-yaml\"\nimport * as Joi from \"joi\"\nimport { join } from \"path\"\nimport { GardenPlugin } from \"../../types/plugin/plugin\"\nimport { validate } from \"../../config/common\"\nimport {\n  gardenPlugin as k8sPlugin,\n  KubernetesBaseConfig,\n  kubernetesConfigBase,\n  KubernetesConfig,\n} from \"./kubernetes\"\nimport { readFile } from \"fs-extra\"\nimport { homedir } from \"os\"\nimport { getLocalEnvironmentStatus, prepareLocalEnvironment } from \"./init\"\n\n// TODO: split this into separate plugins to handle Docker for Mac and Minikube\n\n// note: this is in order of preference, in case neither is set as the current kubectl context\n// and none is explicitly configured in the garden.yml\nconst supportedContexts = [\"docker-for-desktop\", \"minikube\"]\nconst kubeConfigPath = join(homedir(), \".kube\", \"config\")\n\nasync function getKubeConfig(): Promise<any> {\n  try {\n    return safeLoad((await readFile(kubeConfigPath)).toString())\n  } catch {\n    return {}\n  }\n}\n\n/**\n * Automatically set docker environment variables for minikube\n * TODO: it would be better to explicitly provide those to docker instead of using process.env\n */\nasync function setMinikubeDockerEnv() {\n  const minikubeEnv = await execa.stdout(\"minikube\", [\"docker-env\", \"--shell=bash\"])\n  for (const line of minikubeEnv.split(\"\\n\")) {\n    const matched = line.match(/^export (\\w+)=\"(.+)\"$/)\n    if (matched) {\n      process.env[matched[1]] = matched[2]\n    }\n  }\n}\n\nexport interface LocalKubernetesConfig extends KubernetesBaseConfig {\n  _system?: Symbol\n  _systemServices?: string[]\n}\n\nconst configSchema = kubernetesConfigBase\n  .keys({\n    ingressHostname: Joi.string()\n      .description(\"The hostname of the cluster's ingress controller.\"),\n    _system: Joi.any().meta({ internal: true }),\n    _systemServices: Joi.array().items(Joi.string())\n      .meta({ internal: true })\n      .description(\"The system services which should be automatically deployed to the cluster.\"),\n  })\n  .description(\"The provider configuration for the local-kubernetes plugin.\")\n\nexport const name = \"local-kubernetes\"\n\nexport async function gardenPlugin({ projectName, config, logEntry }): Promise<GardenPlugin> {\n  config = validate(config, configSchema, { context: \"local-kubernetes provider config\" })\n\n  let context = config.context\n  let defaultHostname = config.defaultHostname\n  let systemServices\n\n  if (!context) {\n    // automatically detect supported kubectl context if not explicitly configured\n    const kubeConfig = await getKubeConfig()\n    const currentContext = kubeConfig[\"current-context\"]\n\n    if (currentContext && supportedContexts.includes(currentContext)) {\n      // prefer current context if set and supported\n      context = currentContext\n      logEntry.debug({ section: name, msg: `Using current context: ${context}` })\n    } else if (kubeConfig.contexts) {\n      const availableContexts = kubeConfig.contexts.map(c => c.name)\n\n      for (const supportedContext of supportedContexts) {\n        if (availableContexts.includes(supportedContext)) {\n          context = supportedContext\n          logEntry.debug({ section: name, msg: `Using detected context: ${context}` })\n          break\n        }\n      }\n    }\n  }\n\n  if (!context) {\n    context = supportedContexts[0]\n    logEntry.debug({ section: name, msg: `No kubectl context auto-detected, using default: ${context}` })\n  }\n\n  if (context === \"minikube\") {\n    await execa(\"minikube\", [\"config\", \"set\", \"WantUpdateNotification\", \"false\"])\n\n    if (!defaultHostname) {\n      // use the nip.io service to give a hostname to the instance, if none is explicitly configured\n      const minikubeIp = await execa.stdout(\"minikube\", [\"ip\"])\n      defaultHostname = `${projectName}.${minikubeIp}.nip.io`\n    }\n\n    await Promise.all([\n      // TODO: wait for ingress addon to be ready, if it was previously disabled\n      execa(\"minikube\", [\"addons\", \"enable\", \"ingress\"]),\n      setMinikubeDockerEnv(),\n    ])\n\n    systemServices = []\n  } else {\n    if (!defaultHostname) {\n      defaultHostname = `${projectName}.local.app.garden`\n    }\n  }\n\n  const k8sConfig: KubernetesConfig = {\n    name: config.name,\n    context,\n    defaultHostname,\n    defaultUsername: \"default\",\n    deploymentRegistry: {\n      hostname: \"foo.garden\",   // this is not used by this plugin, but required by the base plugin\n      namespace: \"_\",\n    },\n    forceSsl: false,\n    imagePullSecrets: config.imagePullSecrets,\n    ingressHttpPort: 80,\n    ingressHttpsPort: 443,\n    ingressClass: \"nginx\",\n    tlsCertificates: config.tlsCertificates,\n    // TODO: support SSL on local deployments\n    _system: config._system,\n    _systemServices: systemServices,\n  }\n\n  const plugin = k8sPlugin({ config: k8sConfig })\n\n  // override the environment configuration steps\n  plugin.actions!.getEnvironmentStatus = getLocalEnvironmentStatus\n  plugin.actions!.prepareEnvironment = prepareLocalEnvironment\n\n  // no need to push before deploying locally\n  delete plugin.moduleActions!.container.pushModule\n\n  return plugin\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/namespace.d.ts b/garden-service/build/plugins/kubernetes/namespace.d.ts new file mode 100644 index 00000000000..6ea6c81207a --- /dev/null +++ b/garden-service/build/plugins/kubernetes/namespace.d.ts @@ -0,0 +1,14 @@ +import { PluginContext } from "../../plugin-context"; +import { KubeApi } from "./api"; +import { KubernetesProvider } from "./kubernetes"; +export declare function ensureNamespace(api: KubeApi, namespace: string): Promise; +export declare function getNamespace({ ctx, provider, suffix, skipCreate }: { + ctx: PluginContext; + provider: KubernetesProvider; + suffix?: string; + skipCreate?: boolean; +}): Promise; +export declare function getAppNamespace(ctx: PluginContext, provider: KubernetesProvider): Promise; +export declare function getMetadataNamespace(ctx: PluginContext, provider: KubernetesProvider): Promise; +export declare function getAllGardenNamespaces(api: KubeApi): Promise; +//# sourceMappingURL=namespace.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/namespace.js b/garden-service/build/plugins/kubernetes/namespace.js new file mode 100644 index 00000000000..32631ad1c12 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/namespace.js @@ -0,0 +1,99 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const api_1 = require("./api"); +const kubernetes_1 = require("./kubernetes"); +const exceptions_1 = require("../../exceptions"); +const created = {}; +function ensureNamespace(api, namespace) { + return __awaiter(this, void 0, void 0, function* () { + if (!created[namespace]) { + const namespacesStatus = yield api.core.listNamespace(); + for (const n of namespacesStatus.body.items) { + if (n.status.phase === "Active") { + created[n.metadata.name] = true; + } + } + if (!created[namespace]) { + // TODO: the types for all the create functions in the library are currently broken + yield api.core.createNamespace({ + apiVersion: "v1", + kind: "Namespace", + metadata: { + name: namespace, + annotations: { + "garden.io/generated": "true", + }, + }, + }); + created[namespace] = true; + } + } + }); +} +exports.ensureNamespace = ensureNamespace; +function getNamespace({ ctx, provider, suffix, skipCreate }) { + return __awaiter(this, void 0, void 0, function* () { + let namespace; + if (provider.config.namespace) { + namespace = provider.config.namespace; + } + else { + const localConfig = yield ctx.localConfigStore.get(); + const k8sConfig = localConfig.kubernetes || {}; + let { username, ["previous-usernames"]: previousUsernames } = k8sConfig; + if (!username) { + username = provider.config.defaultUsername; + } + if (!username) { + throw new exceptions_1.AuthenticationError(`User not logged into provider ${kubernetes_1.name}. Please specify defaultUsername in provider ` + + `config or run garden init.`, { previousUsernames, provider: kubernetes_1.name }); + } + namespace = `garden--${username}--${ctx.projectName}`; + } + if (suffix) { + namespace = `${namespace}--${suffix}`; + } + if (!skipCreate) { + const api = new api_1.KubeApi(provider); + yield ensureNamespace(api, namespace); + } + return namespace; + }); +} +exports.getNamespace = getNamespace; +function getAppNamespace(ctx, provider) { + return __awaiter(this, void 0, void 0, function* () { + return getNamespace({ ctx, provider }); + }); +} +exports.getAppNamespace = getAppNamespace; +function getMetadataNamespace(ctx, provider) { + return getNamespace({ ctx, provider, suffix: "metadata" }); +} +exports.getMetadataNamespace = getMetadataNamespace; +function getAllGardenNamespaces(api) { + return __awaiter(this, void 0, void 0, function* () { + const allNamespaces = yield api.core.listNamespace(); + return allNamespaces.body.items + .map(n => n.metadata.name) + .filter(n => n.startsWith("garden--")); + }); +} +exports.getAllGardenNamespaces = getAllGardenNamespaces; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBsdWdpbnMva3ViZXJuZXRlcy9uYW1lc3BhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7OztBQUdILCtCQUErQjtBQUUvQiw2Q0FBbUQ7QUFDbkQsaURBQXNEO0FBRXRELE1BQU0sT0FBTyxHQUFnQyxFQUFFLENBQUE7QUFFL0MsU0FBc0IsZUFBZSxDQUFDLEdBQVksRUFBRSxTQUFpQjs7UUFDbkUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRTtZQUN2QixNQUFNLGdCQUFnQixHQUFHLE1BQU0sR0FBRyxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQTtZQUV2RCxLQUFLLE1BQU0sQ0FBQyxJQUFJLGdCQUFnQixDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUU7Z0JBQzNDLElBQUksQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLEtBQUssUUFBUSxFQUFFO29CQUMvQixPQUFPLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUE7aUJBQ2hDO2FBQ0Y7WUFFRCxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFO2dCQUN2QixtRkFBbUY7Z0JBQ25GLE1BQU0sR0FBRyxDQUFDLElBQUksQ0FBQyxlQUFlLENBQU07b0JBQ2xDLFVBQVUsRUFBRSxJQUFJO29CQUNoQixJQUFJLEVBQUUsV0FBVztvQkFDakIsUUFBUSxFQUFFO3dCQUNSLElBQUksRUFBRSxTQUFTO3dCQUNmLFdBQVcsRUFBRTs0QkFDWCxxQkFBcUIsRUFBRSxNQUFNO3lCQUM5QjtxQkFDRjtpQkFDRixDQUFDLENBQUE7Z0JBQ0YsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLElBQUksQ0FBQTthQUMxQjtTQUNGO0lBQ0gsQ0FBQztDQUFBO0FBekJELDBDQXlCQztBQUVELFNBQXNCLFlBQVksQ0FDaEMsRUFBRSxHQUFHLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQzBEOztRQUU3RixJQUFJLFNBQVMsQ0FBQTtRQUViLElBQUksUUFBUSxDQUFDLE1BQU0sQ0FBQyxTQUFTLEVBQUU7WUFDN0IsU0FBUyxHQUFHLFFBQVEsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFBO1NBQ3RDO2FBQU07WUFDTCxNQUFNLFdBQVcsR0FBRyxNQUFNLEdBQUcsQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLEVBQUUsQ0FBQTtZQUNwRCxNQUFNLFNBQVMsR0FBRyxXQUFXLENBQUMsVUFBVSxJQUFJLEVBQUUsQ0FBQTtZQUM5QyxJQUFJLEVBQUUsUUFBUSxFQUFFLENBQUMsb0JBQW9CLENBQUMsRUFBRSxpQkFBaUIsRUFBRSxHQUFHLFNBQVMsQ0FBQTtZQUV2RSxJQUFJLENBQUMsUUFBUSxFQUFFO2dCQUNiLFFBQVEsR0FBRyxRQUFRLENBQUMsTUFBTSxDQUFDLGVBQWUsQ0FBQTthQUMzQztZQUVELElBQUksQ0FBQyxRQUFRLEVBQUU7Z0JBQ2IsTUFBTSxJQUFJLGdDQUFtQixDQUMzQixpQ0FBaUMsaUJBQVksK0NBQStDO29CQUM1Riw0QkFBNEIsRUFDNUIsRUFBRSxpQkFBaUIsRUFBRSxRQUFRLEVBQUUsaUJBQVksRUFBRSxDQUM5QyxDQUFBO2FBQ0Y7WUFFRCxTQUFTLEdBQUcsV0FBVyxRQUFRLEtBQUssR0FBRyxDQUFDLFdBQVcsRUFBRSxDQUFBO1NBQ3REO1FBRUQsSUFBSSxNQUFNLEVBQUU7WUFDVixTQUFTLEdBQUcsR0FBRyxTQUFTLEtBQUssTUFBTSxFQUFFLENBQUE7U0FDdEM7UUFFRCxJQUFJLENBQUMsVUFBVSxFQUFFO1lBQ2YsTUFBTSxHQUFHLEdBQUcsSUFBSSxhQUFPLENBQUMsUUFBUSxDQUFDLENBQUE7WUFDakMsTUFBTSxlQUFlLENBQUMsR0FBRyxFQUFFLFNBQVMsQ0FBQyxDQUFBO1NBQ3RDO1FBRUQsT0FBTyxTQUFTLENBQUE7SUFDbEIsQ0FBQztDQUFBO0FBdENELG9DQXNDQztBQUVELFNBQXNCLGVBQWUsQ0FBQyxHQUFrQixFQUFFLFFBQTRCOztRQUNwRixPQUFPLFlBQVksQ0FBQyxFQUFFLEdBQUcsRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFBO0lBQ3hDLENBQUM7Q0FBQTtBQUZELDBDQUVDO0FBRUQsU0FBZ0Isb0JBQW9CLENBQUMsR0FBa0IsRUFBRSxRQUE0QjtJQUNuRixPQUFPLFlBQVksQ0FBQyxFQUFFLEdBQUcsRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUE7QUFDNUQsQ0FBQztBQUZELG9EQUVDO0FBRUQsU0FBc0Isc0JBQXNCLENBQUMsR0FBWTs7UUFDdkQsTUFBTSxhQUFhLEdBQUcsTUFBTSxHQUFHLENBQUMsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFBO1FBQ3BELE9BQU8sYUFBYSxDQUFDLElBQUksQ0FBQyxLQUFLO2FBQzVCLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDO2FBQ3pCLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQTtJQUMxQyxDQUFDO0NBQUE7QUFMRCx3REFLQyIsImZpbGUiOiJwbHVnaW5zL2t1YmVybmV0ZXMvbmFtZXNwYWNlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoQykgMjAxOCBHYXJkZW4gVGVjaG5vbG9naWVzLCBJbmMuIDxpbmZvQGdhcmRlbi5pbz5cbiAqXG4gKiBUaGlzIFNvdXJjZSBDb2RlIEZvcm0gaXMgc3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhlIE1vemlsbGEgUHVibGljXG4gKiBMaWNlbnNlLCB2LiAyLjAuIElmIGEgY29weSBvZiB0aGUgTVBMIHdhcyBub3QgZGlzdHJpYnV0ZWQgd2l0aCB0aGlzXG4gKiBmaWxlLCBZb3UgY2FuIG9idGFpbiBvbmUgYXQgaHR0cDovL21vemlsbGEub3JnL01QTC8yLjAvLlxuICovXG5cbmltcG9ydCB7IFBsdWdpbkNvbnRleHQgfSBmcm9tIFwiLi4vLi4vcGx1Z2luLWNvbnRleHRcIlxuaW1wb3J0IHsgS3ViZUFwaSB9IGZyb20gXCIuL2FwaVwiXG5pbXBvcnQgeyBLdWJlcm5ldGVzUHJvdmlkZXIgfSBmcm9tIFwiLi9rdWJlcm5ldGVzXCJcbmltcG9ydCB7IG5hbWUgYXMgcHJvdmlkZXJOYW1lIH0gZnJvbSBcIi4va3ViZXJuZXRlc1wiXG5pbXBvcnQgeyBBdXRoZW50aWNhdGlvbkVycm9yIH0gZnJvbSBcIi4uLy4uL2V4Y2VwdGlvbnNcIlxuXG5jb25zdCBjcmVhdGVkOiB7IFtuYW1lOiBzdHJpbmddOiBib29sZWFuIH0gPSB7fVxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gZW5zdXJlTmFtZXNwYWNlKGFwaTogS3ViZUFwaSwgbmFtZXNwYWNlOiBzdHJpbmcpIHtcbiAgaWYgKCFjcmVhdGVkW25hbWVzcGFjZV0pIHtcbiAgICBjb25zdCBuYW1lc3BhY2VzU3RhdHVzID0gYXdhaXQgYXBpLmNvcmUubGlzdE5hbWVzcGFjZSgpXG5cbiAgICBmb3IgKGNvbnN0IG4gb2YgbmFtZXNwYWNlc1N0YXR1cy5ib2R5Lml0ZW1zKSB7XG4gICAgICBpZiAobi5zdGF0dXMucGhhc2UgPT09IFwiQWN0aXZlXCIpIHtcbiAgICAgICAgY3JlYXRlZFtuLm1ldGFkYXRhLm5hbWVdID0gdHJ1ZVxuICAgICAgfVxuICAgIH1cblxuICAgIGlmICghY3JlYXRlZFtuYW1lc3BhY2VdKSB7XG4gICAgICAvLyBUT0RPOiB0aGUgdHlwZXMgZm9yIGFsbCB0aGUgY3JlYXRlIGZ1bmN0aW9ucyBpbiB0aGUgbGlicmFyeSBhcmUgY3VycmVudGx5IGJyb2tlblxuICAgICAgYXdhaXQgYXBpLmNvcmUuY3JlYXRlTmFtZXNwYWNlKDxhbnk+e1xuICAgICAgICBhcGlWZXJzaW9uOiBcInYxXCIsXG4gICAgICAgIGtpbmQ6IFwiTmFtZXNwYWNlXCIsXG4gICAgICAgIG1ldGFkYXRhOiB7XG4gICAgICAgICAgbmFtZTogbmFtZXNwYWNlLFxuICAgICAgICAgIGFubm90YXRpb25zOiB7XG4gICAgICAgICAgICBcImdhcmRlbi5pby9nZW5lcmF0ZWRcIjogXCJ0cnVlXCIsXG4gICAgICAgICAgfSxcbiAgICAgICAgfSxcbiAgICAgIH0pXG4gICAgICBjcmVhdGVkW25hbWVzcGFjZV0gPSB0cnVlXG4gICAgfVxuICB9XG59XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBnZXROYW1lc3BhY2UoXG4gIHsgY3R4LCBwcm92aWRlciwgc3VmZml4LCBza2lwQ3JlYXRlIH06XG4gICAgeyBjdHg6IFBsdWdpbkNvbnRleHQsIHByb3ZpZGVyOiBLdWJlcm5ldGVzUHJvdmlkZXIsIHN1ZmZpeD86IHN0cmluZywgc2tpcENyZWF0ZT86IGJvb2xlYW4gfSxcbik6IFByb21pc2U8c3RyaW5nPiB7XG4gIGxldCBuYW1lc3BhY2VcblxuICBpZiAocHJvdmlkZXIuY29uZmlnLm5hbWVzcGFjZSkge1xuICAgIG5hbWVzcGFjZSA9IHByb3ZpZGVyLmNvbmZpZy5uYW1lc3BhY2VcbiAgfSBlbHNlIHtcbiAgICBjb25zdCBsb2NhbENvbmZpZyA9IGF3YWl0IGN0eC5sb2NhbENvbmZpZ1N0b3JlLmdldCgpXG4gICAgY29uc3QgazhzQ29uZmlnID0gbG9jYWxDb25maWcua3ViZXJuZXRlcyB8fCB7fVxuICAgIGxldCB7IHVzZXJuYW1lLCBbXCJwcmV2aW91cy11c2VybmFtZXNcIl06IHByZXZpb3VzVXNlcm5hbWVzIH0gPSBrOHNDb25maWdcblxuICAgIGlmICghdXNlcm5hbWUpIHtcbiAgICAgIHVzZXJuYW1lID0gcHJvdmlkZXIuY29uZmlnLmRlZmF1bHRVc2VybmFtZVxuICAgIH1cblxuICAgIGlmICghdXNlcm5hbWUpIHtcbiAgICAgIHRocm93IG5ldyBBdXRoZW50aWNhdGlvbkVycm9yKFxuICAgICAgICBgVXNlciBub3QgbG9nZ2VkIGludG8gcHJvdmlkZXIgJHtwcm92aWRlck5hbWV9LiBQbGVhc2Ugc3BlY2lmeSBkZWZhdWx0VXNlcm5hbWUgaW4gcHJvdmlkZXIgYCArXG4gICAgICAgIGBjb25maWcgb3IgcnVuIGdhcmRlbiBpbml0LmAsXG4gICAgICAgIHsgcHJldmlvdXNVc2VybmFtZXMsIHByb3ZpZGVyOiBwcm92aWRlck5hbWUgfSxcbiAgICAgIClcbiAgICB9XG5cbiAgICBuYW1lc3BhY2UgPSBgZ2FyZGVuLS0ke3VzZXJuYW1lfS0tJHtjdHgucHJvamVjdE5hbWV9YFxuICB9XG5cbiAgaWYgKHN1ZmZpeCkge1xuICAgIG5hbWVzcGFjZSA9IGAke25hbWVzcGFjZX0tLSR7c3VmZml4fWBcbiAgfVxuXG4gIGlmICghc2tpcENyZWF0ZSkge1xuICAgIGNvbnN0IGFwaSA9IG5ldyBLdWJlQXBpKHByb3ZpZGVyKVxuICAgIGF3YWl0IGVuc3VyZU5hbWVzcGFjZShhcGksIG5hbWVzcGFjZSlcbiAgfVxuXG4gIHJldHVybiBuYW1lc3BhY2Vcbn1cblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGdldEFwcE5hbWVzcGFjZShjdHg6IFBsdWdpbkNvbnRleHQsIHByb3ZpZGVyOiBLdWJlcm5ldGVzUHJvdmlkZXIpIHtcbiAgcmV0dXJuIGdldE5hbWVzcGFjZSh7IGN0eCwgcHJvdmlkZXIgfSlcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldE1ldGFkYXRhTmFtZXNwYWNlKGN0eDogUGx1Z2luQ29udGV4dCwgcHJvdmlkZXI6IEt1YmVybmV0ZXNQcm92aWRlcikge1xuICByZXR1cm4gZ2V0TmFtZXNwYWNlKHsgY3R4LCBwcm92aWRlciwgc3VmZml4OiBcIm1ldGFkYXRhXCIgfSlcbn1cblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGdldEFsbEdhcmRlbk5hbWVzcGFjZXMoYXBpOiBLdWJlQXBpKTogUHJvbWlzZTxzdHJpbmdbXT4ge1xuICBjb25zdCBhbGxOYW1lc3BhY2VzID0gYXdhaXQgYXBpLmNvcmUubGlzdE5hbWVzcGFjZSgpXG4gIHJldHVybiBhbGxOYW1lc3BhY2VzLmJvZHkuaXRlbXNcbiAgICAubWFwKG4gPT4gbi5tZXRhZGF0YS5uYW1lKVxuICAgIC5maWx0ZXIobiA9PiBuLnN0YXJ0c1dpdGgoXCJnYXJkZW4tLVwiKSlcbn1cbiJdfQ== diff --git a/garden-service/build/plugins/kubernetes/secrets.d.ts b/garden-service/build/plugins/kubernetes/secrets.d.ts new file mode 100644 index 00000000000..722b390e43b --- /dev/null +++ b/garden-service/build/plugins/kubernetes/secrets.d.ts @@ -0,0 +1,17 @@ +import { KubeApi } from "./api"; +import { SecretRef } from "./kubernetes"; +import { GetSecretParams, SetSecretParams, DeleteSecretParams } from "../../types/plugin/params"; +export declare function getSecret({ ctx, key }: GetSecretParams): Promise<{ + value: string; +} | { + value: null; +}>; +export declare function setSecret({ ctx, key, value }: SetSecretParams): Promise<{}>; +export declare function deleteSecret({ ctx, key }: DeleteSecretParams): Promise<{ + found: boolean; +}>; +/** + * Make sure the specified secret exists in the target namespace, copying it if necessary. + */ +export declare function ensureSecret(api: KubeApi, secretRef: SecretRef, targetNamespace: string): Promise; +//# sourceMappingURL=secrets.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/secrets.js b/garden-service/build/plugins/kubernetes/secrets.js new file mode 100644 index 00000000000..f8dc20db483 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/secrets.js @@ -0,0 +1,123 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const api_1 = require("./api"); +const exceptions_1 = require("../../exceptions"); +const namespace_1 = require("./namespace"); +function getSecret({ ctx, key }) { + return __awaiter(this, void 0, void 0, function* () { + const api = new api_1.KubeApi(ctx.provider); + const ns = yield namespace_1.getMetadataNamespace(ctx, ctx.provider); + try { + const res = yield api.core.readNamespacedSecret(key, ns); + return { value: Buffer.from(res.body.data.value, "base64").toString() }; + } + catch (err) { + if (err.code === 404) { + return { value: null }; + } + else { + throw err; + } + } + }); +} +exports.getSecret = getSecret; +function setSecret({ ctx, key, value }) { + return __awaiter(this, void 0, void 0, function* () { + // we store configuration in a separate metadata namespace, so that configs aren't cleared when wiping the namespace + const api = new api_1.KubeApi(ctx.provider); + const ns = yield namespace_1.getMetadataNamespace(ctx, ctx.provider); + const body = { + body: { + apiVersion: "v1", + kind: "Secret", + metadata: { + name: key, + annotations: { + "garden.io/generated": "true", + }, + }, + type: "generic", + stringData: { value }, + }, + }; + try { + yield api.core.createNamespacedSecret(ns, body); + } + catch (err) { + if (err.code === 409) { + yield api.core.patchNamespacedSecret(key, ns, body); + } + else { + throw err; + } + } + return {}; + }); +} +exports.setSecret = setSecret; +function deleteSecret({ ctx, key }) { + return __awaiter(this, void 0, void 0, function* () { + const api = new api_1.KubeApi(ctx.provider); + const ns = yield namespace_1.getMetadataNamespace(ctx, ctx.provider); + try { + yield api.core.deleteNamespacedSecret(key, ns, {}); + } + catch (err) { + if (err.code === 404) { + return { found: false }; + } + else { + throw err; + } + } + return { found: true }; + }); +} +exports.deleteSecret = deleteSecret; +/** + * Make sure the specified secret exists in the target namespace, copying it if necessary. + */ +function ensureSecret(api, secretRef, targetNamespace) { + return __awaiter(this, void 0, void 0, function* () { + let secret; + try { + secret = (yield api.core.readNamespacedSecret(secretRef.name, secretRef.namespace)).body; + } + catch (err) { + if (err.code === 404) { + throw new exceptions_1.ConfigurationError(`Could not find secret '${secretRef.name}' in namespace '${secretRef.namespace}'. ` + + `Have you correctly configured your secrets?`, { + secretRef, + }); + } + else { + throw err; + } + } + if (secretRef.namespace === targetNamespace) { + return; + } + delete secret.metadata.resourceVersion; + secret.metadata.namespace = targetNamespace; + yield api.upsert("Secret", targetNamespace, secret); + }); +} +exports.ensureSecret = ensureSecret; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/plugins/kubernetes/service.d.ts b/garden-service/build/plugins/kubernetes/service.d.ts new file mode 100644 index 00000000000..8281642a749 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/service.d.ts @@ -0,0 +1,3 @@ +import { ContainerService } from "../container"; +export declare function createServices(service: ContainerService, namespace: string): Promise; +//# sourceMappingURL=service.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/service.js b/garden-service/build/plugins/kubernetes/service.js new file mode 100644 index 00000000000..208293caf06 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/service.js @@ -0,0 +1,70 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +function createServices(service, namespace) { + return __awaiter(this, void 0, void 0, function* () { + const services = []; + const addService = (name, type, servicePorts) => { + services.push({ + apiVersion: "v1", + kind: "Service", + metadata: { + name, + annotations: {}, + namespace, + }, + spec: { + ports: servicePorts, + selector: { + service: service.name, + }, + type, + }, + }); + }; + // first add internally exposed (ClusterIP) service + const internalPorts = []; + const ports = service.spec.ports; + for (const portSpec of ports) { + internalPorts.push({ + name: portSpec.name, + protocol: portSpec.protocol, + targetPort: portSpec.containerPort, + port: portSpec.containerPort, + }); + } + if (internalPorts.length) { + addService(service.name, "ClusterIP", internalPorts); + } + // optionally add a NodePort service for externally open ports, if applicable + // TODO: explore nicer ways to do this + const exposedPorts = ports.filter(portSpec => portSpec.nodePort); + if (exposedPorts.length > 0) { + addService(service.name + "-nodeport", "NodePort", exposedPorts.map(portSpec => ({ + // TODO: do the parsing and defaults when loading the yaml + name: portSpec.name, + protocol: portSpec.protocol, + port: portSpec.containerPort, + nodePort: portSpec.nodePort, + }))); + } + return services; + }); +} +exports.createServices = createServices; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/plugins/kubernetes/status.d.ts b/garden-service/build/plugins/kubernetes/status.d.ts new file mode 100644 index 00000000000..ce76b2e4b1a --- /dev/null +++ b/garden-service/build/plugins/kubernetes/status.d.ts @@ -0,0 +1,50 @@ +import { PluginContext } from "../../plugin-context"; +import { Service, ServiceState } from "../../types/service"; +import { KubeApi } from "./api"; +import { KubernetesObject } from "./helm"; +import { KubernetesProvider } from "./kubernetes"; +import { LogEntry } from "../../logger/log-entry"; +export interface RolloutStatus { + state: ServiceState; + obj: KubernetesObject; + lastMessage?: string; + lastError?: string; + resourceVersion?: number; +} +/** + * Check the rollout status for the given Deployment, DaemonSet or StatefulSet. + * + * NOTE: This mostly replicates the logic in `kubectl rollout status`. Using that directly here + * didn't pan out, since it doesn't look for events and just times out when errors occur during rollout. + */ +export declare function checkDeploymentStatus(api: KubeApi, namespace: string, obj: KubernetesObject, resourceVersion?: number): Promise; +/** + * Check if the specified Kubernetes objects are deployed and fully rolled out + */ +export declare function checkObjectStatus(api: KubeApi, namespace: string, objects: KubernetesObject[], prevStatuses?: RolloutStatus[]): Promise<{ + ready: boolean; + statuses: RolloutStatus[]; +}>; +interface WaitParams { + ctx: PluginContext; + provider: KubernetesProvider; + service: Service; + objects: KubernetesObject[]; + logEntry?: LogEntry; +} +/** + * Wait until the rollout is complete for each of the given Kubernetes objects + */ +export declare function waitForObjects({ ctx, provider, service, objects, logEntry }: WaitParams): Promise; +/** + * Check if each of the given Kubernetes objects matches what's installed in the cluster + */ +export declare function compareDeployedObjects(ctx: PluginContext, objects: KubernetesObject[]): Promise; +/** + * Recursively removes all null value properties from objects + */ +export declare function removeNull(value: T | Iterable): T | Iterable | { + [K in keyof T]: T[K]; +}; +export {}; +//# sourceMappingURL=status.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/status.js b/garden-service/build/plugins/kubernetes/status.js new file mode 100644 index 00000000000..4905ece5c35 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/status.js @@ -0,0 +1,374 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const exceptions_1 = require("../../exceptions"); +const util_1 = require("../../util/util"); +const api_1 = require("./api"); +const kubectl_1 = require("./kubectl"); +const namespace_1 = require("./namespace"); +const Bluebird = require("bluebird"); +const lodash_1 = require("lodash"); +const is_subset_1 = require("../../util/is-subset"); +// Handlers to check the rollout status for K8s objects where that applies. +// Using https://github.com/kubernetes/helm/blob/master/pkg/kube/wait.go as a reference here. +const objHandlers = { + DaemonSet: checkDeploymentStatus, + Deployment: checkDeploymentStatus, + StatefulSet: checkDeploymentStatus, + PersistentVolumeClaim: (api, namespace, obj) => __awaiter(this, void 0, void 0, function* () { + const res = yield api.core.readNamespacedPersistentVolumeClaim(obj.metadata.name, namespace); + const state = res.body.status.phase === "Bound" ? "ready" : "deploying"; + return { state, obj }; + }), + Pod: (api, namespace, obj) => __awaiter(this, void 0, void 0, function* () { + const res = yield api.core.readNamespacedPod(obj.metadata.name, namespace); + return checkPodStatus(obj, [res.body]); + }), + ReplicaSet: (api, namespace, obj) => __awaiter(this, void 0, void 0, function* () { + const res = yield api.core.listNamespacedPod(namespace, undefined, undefined, undefined, true, obj.spec.selector.matchLabels); + return checkPodStatus(obj, res.body.items); + }), + ReplicationController: (api, namespace, obj) => __awaiter(this, void 0, void 0, function* () { + const res = yield api.core.listNamespacedPod(namespace, undefined, undefined, undefined, true, obj.spec.selector); + return checkPodStatus(obj, res.body.items); + }), + Service: (api, namespace, obj) => __awaiter(this, void 0, void 0, function* () { + if (obj.spec.type === "ExternalName") { + return { state: "ready", obj }; + } + const status = yield api.core.readNamespacedService(obj.metadata.name, namespace); + if (obj.spec.clusterIP !== "None" && status.body.spec.clusterIP === "") { + return { state: "deploying", obj }; + } + if (obj.spec.type === "LoadBalancer" && !status.body.status.loadBalancer.ingress) { + return { state: "deploying", obj }; + } + return { state: "ready", obj }; + }), +}; +function checkPodStatus(obj, pods) { + return __awaiter(this, void 0, void 0, function* () { + for (const pod of pods) { + const ready = lodash_1.some(pod.status.conditions.map(c => c.type === "ready")); + if (!ready) { + return { state: "deploying", obj }; + } + } + return { state: "ready", obj }; + }); +} +/** + * Check the rollout status for the given Deployment, DaemonSet or StatefulSet. + * + * NOTE: This mostly replicates the logic in `kubectl rollout status`. Using that directly here + * didn't pan out, since it doesn't look for events and just times out when errors occur during rollout. + */ +function checkDeploymentStatus(api, namespace, obj, resourceVersion) { + return __awaiter(this, void 0, void 0, function* () { + // + const out = { + state: "unhealthy", + obj, + resourceVersion, + }; + let statusRes; + try { + statusRes = (yield api.readBySpec(namespace, obj)).body; + } + catch (err) { + if (err.code && err.code === 404) { + // service is not running + return out; + } + else { + throw err; + } + } + if (!resourceVersion) { + resourceVersion = out.resourceVersion = parseInt(statusRes.metadata.resourceVersion, 10); + } + // TODO: try to come up with something more efficient. may need to wait for newer k8s version. + // note: the resourceVersion parameter does not appear to work... + const eventsRes = yield api.core.listNamespacedEvent(namespace); + // const eventsRes = await this.kubeApi( + // "GET", + // [ + // "apis", apiSection, "v1beta1", + // "watch", + // "namespaces", namespace, + // type + "s", service.fullName, + // ], + // { resourceVersion, watch: "false" }, + // ) + // look for errors and warnings in the events for the service, abort if we find any + const events = eventsRes.body.items; + for (let event of events) { + const eventVersion = parseInt(event.metadata.resourceVersion, 10); + if (eventVersion <= resourceVersion || + (!event.metadata.name.startsWith(obj.metadata.name + ".") + && + !event.metadata.name.startsWith(obj.metadata.name + "-"))) { + continue; + } + if (eventVersion > resourceVersion) { + out.resourceVersion = eventVersion; + } + if (event.type === "Warning" || event.type === "Error") { + if (event.reason === "Unhealthy") { + // still waiting on readiness probe + continue; + } + out.state = "unhealthy"; + out.lastError = `${event.reason} - ${event.message}`; + return out; + } + let message = event.message; + if (event.reason === event.reason.toUpperCase()) { + // some events like ingress events are formatted this way + message = `${event.reason} ${message}`; + } + if (message) { + out.lastMessage = message; + } + } + // See `https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/rollout_status.go` for a reference + // for this logic. + out.state = "ready"; + let statusMsg = ""; + if (statusRes.metadata.generation > statusRes.status.observedGeneration) { + statusMsg = `Waiting for spec update to be observed...`; + out.state = "deploying"; + } + else if (obj.kind === "DaemonSet") { + const status = statusRes.status; + const desired = status.desiredNumberScheduled || 0; + const updated = status.updatedNumberScheduled || 0; + const available = status.numberAvailable || 0; + if (updated < desired) { + statusMsg = `Waiting for rollout: ${updated} out of ${desired} new pods updated...`; + out.state = "deploying"; + } + else if (available < desired) { + statusMsg = `Waiting for rollout: ${available} out of ${desired} updated pods available...`; + out.state = "deploying"; + } + } + else if (obj.kind === "StatefulSet") { + const status = statusRes.status; + const statusSpec = statusRes.spec; + const replicas = status.replicas; + const updated = status.updatedReplicas || 0; + const ready = status.readyReplicas || 0; + if (replicas && ready < replicas) { + statusMsg = `Waiting for rollout: ${ready} out of ${replicas} new pods updated...`; + out.state = "deploying"; + } + else if (statusSpec.updateStrategy.type === "RollingUpdate" && statusSpec.updateStrategy.rollingUpdate) { + if (replicas && statusSpec.updateStrategy.rollingUpdate.partition) { + const desired = replicas - statusSpec.updateStrategy.rollingUpdate.partition; + if (updated < desired) { + statusMsg = + `Waiting for partitioned roll out to finish: ${updated} out of ${desired} new pods have been updated...`; + out.state = "deploying"; + } + } + } + else if (status.updateRevision !== status.currentRevision) { + statusMsg = `Waiting for rolling update to complete...`; + out.state = "deploying"; + } + } + else { + const status = statusRes.status; + const desired = 1; // TODO: service.count[env.name] || 1 + const updated = status.updatedReplicas || 0; + const replicas = status.replicas || 0; + const available = status.availableReplicas || 0; + if (updated < desired) { + statusMsg = `Waiting for rollout: ${updated} out of ${desired} new replicas updated...`; + out.state = "deploying"; + } + else if (replicas > updated) { + statusMsg = `Waiting for rollout: ${replicas - updated} old replicas pending termination...`; + out.state = "deploying"; + } + else if (available < updated) { + statusMsg = `Waiting for rollout: ${available} out of ${updated} updated replicas available...`; + out.state = "deploying"; + } + } + out.lastMessage = statusMsg; + return out; + }); +} +exports.checkDeploymentStatus = checkDeploymentStatus; +/** + * Check if the specified Kubernetes objects are deployed and fully rolled out + */ +function checkObjectStatus(api, namespace, objects, prevStatuses) { + return __awaiter(this, void 0, void 0, function* () { + let ready = true; + const statuses = yield Bluebird.map(objects, (obj, i) => __awaiter(this, void 0, void 0, function* () { + const handler = objHandlers[obj.kind]; + const prevStatus = prevStatuses && prevStatuses[i]; + const status = handler + ? yield handler(api, namespace, obj, prevStatus && prevStatus.resourceVersion) + // if there is no explicit handler to check the status, we assume there's no rollout phase to wait for + : { state: "ready", obj }; + if (status.state !== "ready") { + ready = false; + } + return status; + })); + return { ready, statuses }; + }); +} +exports.checkObjectStatus = checkObjectStatus; +/** + * Wait until the rollout is complete for each of the given Kubernetes objects + */ +function waitForObjects({ ctx, provider, service, objects, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + let loops = 0; + let lastMessage; + const startTime = new Date().getTime(); + logEntry && logEntry.verbose({ + symbol: "info", + section: service.name, + msg: `Waiting for service to be ready...`, + }); + const api = new api_1.KubeApi(provider); + const namespace = yield namespace_1.getAppNamespace(ctx, provider); + let prevStatuses = objects.map((obj) => ({ + state: "unknown", + obj, + })); + while (true) { + yield util_1.sleep(2000 + 1000 * loops); + const { ready, statuses } = yield checkObjectStatus(api, namespace, objects, prevStatuses); + for (const status of statuses) { + if (status.lastError) { + throw new exceptions_1.DeploymentError(`Error deploying ${service.name}: ${status.lastError}`, { + serviceName: service.name, + status, + }); + } + if (status.lastMessage && (!lastMessage || status.lastMessage !== lastMessage)) { + lastMessage = status.lastMessage; + logEntry && logEntry.verbose({ + symbol: "info", + section: service.name, + msg: status.lastMessage, + }); + } + } + prevStatuses = statuses; + if (ready) { + break; + } + const now = new Date().getTime(); + if (now - startTime > kubectl_1.KUBECTL_DEFAULT_TIMEOUT * 1000) { + throw new Error(`Timed out waiting for ${service.name} to deploy`); + } + } + logEntry && logEntry.verbose({ symbol: "info", section: service.name, msg: `Service deployed` }); + }); +} +exports.waitForObjects = waitForObjects; +/** + * Check if each of the given Kubernetes objects matches what's installed in the cluster + */ +function compareDeployedObjects(ctx, objects) { + return __awaiter(this, void 0, void 0, function* () { + const existingObjects = yield Bluebird.map(objects, obj => getDeployedObject(ctx, ctx.provider, obj)); + for (let [obj, existingSpec] of lodash_1.zip(objects, existingObjects)) { + if (existingSpec && obj) { + // the API version may implicitly change when deploying + existingSpec.apiVersion = obj.apiVersion; + // the namespace property is silently dropped when added to non-namespaced + if (obj.metadata.namespace && existingSpec.metadata.namespace === undefined) { + delete obj.metadata.namespace; + } + if (!existingSpec.metadata.annotations) { + existingSpec.metadata.annotations = {}; + } + // handle auto-filled properties (this is a bit of a design issue in the K8s API) + if (obj.kind === "Service" && obj.spec.clusterIP === "") { + delete obj.spec.clusterIP; + } + // handle properties that are omitted in the response because they have the default value + // (another design issue in the K8s API) + // NOTE: this approach won't fly in the long run, but hopefully we can climb out of this mess when + // `kubectl diff` is ready, or server-side apply/diff is ready + if (obj.kind === "DaemonSet") { + if (obj.spec.minReadySeconds === 0) { + delete obj.spec.minReadySeconds; + } + if (obj.spec.template.spec.hostNetwork === false) { + delete obj.spec.template.spec.hostNetwork; + } + } + // clean null values + obj = removeNull(obj); + } + if (!existingSpec || !is_subset_1.isSubset(existingSpec, obj)) { + // console.log(JSON.stringify(obj, null, 4)) + // console.log(JSON.stringify(existingSpec, null, 4)) + // console.log("----------------------------------------------------") + // throw new Error("bla") + return false; + } + } + return true; + }); +} +exports.compareDeployedObjects = compareDeployedObjects; +function getDeployedObject(ctx, provider, obj) { + return __awaiter(this, void 0, void 0, function* () { + const api = new api_1.KubeApi(provider); + const namespace = obj.metadata.namespace || (yield namespace_1.getAppNamespace(ctx, provider)); + try { + const res = yield api.readBySpec(namespace, obj); + return res.body; + } + catch (err) { + if (err.code === 404) { + return null; + } + else { + throw err; + } + } + }); +} +/** + * Recursively removes all null value properties from objects + */ +function removeNull(value) { + if (lodash_1.isArray(value)) { + return value.map(removeNull); + } + else if (lodash_1.isPlainObject(value)) { + return lodash_1.mapValues(lodash_1.pickBy(value, v => v !== null), removeNull); + } + else { + return value; + } +} +exports.removeNull = removeNull; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/kubernetes/status.ts"],"names":[],"mappings":"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","file":"plugins/kubernetes/status.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { DeploymentError } from \"../../exceptions\"\nimport { PluginContext } from \"../../plugin-context\"\nimport { Service, ServiceState } from \"../../types/service\"\nimport { sleep } from \"../../util/util\"\nimport { KubeApi } from \"./api\"\nimport { KUBECTL_DEFAULT_TIMEOUT } from \"./kubectl\"\nimport { getAppNamespace } from \"./namespace\"\nimport * as Bluebird from \"bluebird\"\nimport { KubernetesObject } from \"./helm\"\nimport {\n  V1Pod,\n  V1Deployment,\n  V1DaemonSet,\n  V1DaemonSetStatus,\n  V1StatefulSetStatus,\n  V1StatefulSet,\n  V1StatefulSetSpec,\n  V1DeploymentStatus,\n} from \"@kubernetes/client-node\"\nimport { some, zip, isArray, isPlainObject, pickBy, mapValues } from \"lodash\"\nimport { KubernetesProvider } from \"./kubernetes\"\nimport { LogEntry } from \"../../logger/log-entry\"\nimport { isSubset } from \"../../util/is-subset\"\n\nexport interface RolloutStatus {\n  state: ServiceState\n  obj: KubernetesObject\n  lastMessage?: string\n  lastError?: string\n  resourceVersion?: number\n}\n\ninterface ObjHandler {\n  (api: KubeApi, namespace: string, obj: KubernetesObject, resourceVersion?: number): Promise<RolloutStatus>\n}\n\n// Handlers to check the rollout status for K8s objects where that applies.\n// Using https://github.com/kubernetes/helm/blob/master/pkg/kube/wait.go as a reference here.\nconst objHandlers: { [kind: string]: ObjHandler } = {\n  DaemonSet: checkDeploymentStatus,\n  Deployment: checkDeploymentStatus,\n  StatefulSet: checkDeploymentStatus,\n\n  PersistentVolumeClaim: async (api, namespace, obj) => {\n    const res = await api.core.readNamespacedPersistentVolumeClaim(obj.metadata.name, namespace)\n    const state: ServiceState = res.body.status.phase === \"Bound\" ? \"ready\" : \"deploying\"\n    return { state, obj }\n  },\n\n  Pod: async (api, namespace, obj) => {\n    const res = await api.core.readNamespacedPod(obj.metadata.name, namespace)\n    return checkPodStatus(obj, [res.body])\n  },\n\n  ReplicaSet: async (api, namespace, obj) => {\n    const res = await api.core.listNamespacedPod(\n      namespace, undefined, undefined, undefined, true, obj.spec.selector.matchLabels,\n    )\n    return checkPodStatus(obj, res.body.items)\n  },\n  ReplicationController: async (api, namespace, obj) => {\n    const res = await api.core.listNamespacedPod(\n      namespace, undefined, undefined, undefined, true, obj.spec.selector,\n    )\n    return checkPodStatus(obj, res.body.items)\n  },\n\n  Service: async (api, namespace, obj) => {\n    if (obj.spec.type === \"ExternalName\") {\n      return { state: \"ready\", obj }\n    }\n\n    const status = await api.core.readNamespacedService(obj.metadata.name, namespace)\n\n    if (obj.spec.clusterIP !== \"None\" && status.body.spec.clusterIP === \"\") {\n      return { state: \"deploying\", obj }\n    }\n\n    if (obj.spec.type === \"LoadBalancer\" && !status.body.status.loadBalancer.ingress) {\n      return { state: \"deploying\", obj }\n    }\n\n    return { state: \"ready\", obj }\n  },\n}\n\nasync function checkPodStatus(obj: KubernetesObject, pods: V1Pod[]): Promise<RolloutStatus> {\n  for (const pod of pods) {\n    const ready = some(pod.status.conditions.map(c => c.type === \"ready\"))\n    if (!ready) {\n      return { state: \"deploying\", obj }\n    }\n  }\n\n  return { state: \"ready\", obj }\n}\n\n/**\n * Check the rollout status for the given Deployment, DaemonSet or StatefulSet.\n *\n * NOTE: This mostly replicates the logic in `kubectl rollout status`. Using that directly here\n * didn't pan out, since it doesn't look for events and just times out when errors occur during rollout.\n */\nexport async function checkDeploymentStatus(\n  api: KubeApi, namespace: string, obj: KubernetesObject, resourceVersion?: number,\n): Promise<RolloutStatus> {\n  //\n  const out: RolloutStatus = {\n    state: \"unhealthy\",\n    obj,\n    resourceVersion,\n  }\n\n  let statusRes: V1Deployment | V1DaemonSet | V1StatefulSet\n\n  try {\n    statusRes = <V1Deployment | V1DaemonSet | V1StatefulSet>(await api.readBySpec(namespace, obj)).body\n  } catch (err) {\n    if (err.code && err.code === 404) {\n      // service is not running\n      return out\n    } else {\n      throw err\n    }\n  }\n\n  if (!resourceVersion) {\n    resourceVersion = out.resourceVersion = parseInt(statusRes.metadata.resourceVersion, 10)\n  }\n\n  // TODO: try to come up with something more efficient. may need to wait for newer k8s version.\n  // note: the resourceVersion parameter does not appear to work...\n  const eventsRes = await api.core.listNamespacedEvent(namespace)\n\n  // const eventsRes = await this.kubeApi(\n  //   \"GET\",\n  //   [\n  //     \"apis\", apiSection, \"v1beta1\",\n  //     \"watch\",\n  //     \"namespaces\", namespace,\n  //     type + \"s\", service.fullName,\n  //   ],\n  //   { resourceVersion, watch: \"false\" },\n  // )\n\n  // look for errors and warnings in the events for the service, abort if we find any\n  const events = eventsRes.body.items\n\n  for (let event of events) {\n    const eventVersion = parseInt(event.metadata.resourceVersion, 10)\n\n    if (\n      eventVersion <= <number>resourceVersion ||\n      (\n        !event.metadata.name.startsWith(obj.metadata.name + \".\")\n        &&\n        !event.metadata.name.startsWith(obj.metadata.name + \"-\")\n      )\n    ) {\n      continue\n    }\n\n    if (eventVersion > <number>resourceVersion) {\n      out.resourceVersion = eventVersion\n    }\n\n    if (event.type === \"Warning\" || event.type === \"Error\") {\n      if (event.reason === \"Unhealthy\") {\n        // still waiting on readiness probe\n        continue\n      }\n      out.state = \"unhealthy\"\n      out.lastError = `${event.reason} - ${event.message}`\n      return out\n    }\n\n    let message = event.message\n\n    if (event.reason === event.reason.toUpperCase()) {\n      // some events like ingress events are formatted this way\n      message = `${event.reason} ${message}`\n    }\n\n    if (message) {\n      out.lastMessage = message\n    }\n  }\n\n  // See `https://github.com/kubernetes/kubernetes/blob/master/pkg/kubectl/rollout_status.go` for a reference\n  // for this logic.\n  out.state = \"ready\"\n  let statusMsg = \"\"\n\n  if (statusRes.metadata.generation > statusRes.status.observedGeneration) {\n    statusMsg = `Waiting for spec update to be observed...`\n    out.state = \"deploying\"\n  } else if (obj.kind === \"DaemonSet\") {\n    const status = <V1DaemonSetStatus>statusRes.status\n\n    const desired = status.desiredNumberScheduled || 0\n    const updated = status.updatedNumberScheduled || 0\n    const available = status.numberAvailable || 0\n\n    if (updated < desired) {\n      statusMsg = `Waiting for rollout: ${updated} out of ${desired} new pods updated...`\n      out.state = \"deploying\"\n    } else if (available < desired) {\n      statusMsg = `Waiting for rollout: ${available} out of ${desired} updated pods available...`\n      out.state = \"deploying\"\n    }\n  } else if (obj.kind === \"StatefulSet\") {\n    const status = <V1StatefulSetStatus>statusRes.status\n    const statusSpec = <V1StatefulSetSpec>statusRes.spec\n\n    const replicas = status.replicas\n    const updated = status.updatedReplicas || 0\n    const ready = status.readyReplicas || 0\n\n    if (replicas && ready < replicas) {\n      statusMsg = `Waiting for rollout: ${ready} out of ${replicas} new pods updated...`\n      out.state = \"deploying\"\n    } else if (statusSpec.updateStrategy.type === \"RollingUpdate\" && statusSpec.updateStrategy.rollingUpdate) {\n      if (replicas && statusSpec.updateStrategy.rollingUpdate.partition) {\n        const desired = replicas - statusSpec.updateStrategy.rollingUpdate.partition\n        if (updated < desired) {\n          statusMsg =\n            `Waiting for partitioned roll out to finish: ${updated} out of ${desired} new pods have been updated...`\n          out.state = \"deploying\"\n        }\n      }\n    } else if (status.updateRevision !== status.currentRevision) {\n      statusMsg = `Waiting for rolling update to complete...`\n      out.state = \"deploying\"\n    }\n  } else {\n    const status = <V1DeploymentStatus>statusRes.status\n\n    const desired = 1 // TODO: service.count[env.name] || 1\n    const updated = status.updatedReplicas || 0\n    const replicas = status.replicas || 0\n    const available = status.availableReplicas || 0\n\n    if (updated < desired) {\n      statusMsg = `Waiting for rollout: ${updated} out of ${desired} new replicas updated...`\n      out.state = \"deploying\"\n    } else if (replicas > updated) {\n      statusMsg = `Waiting for rollout: ${replicas - updated} old replicas pending termination...`\n      out.state = \"deploying\"\n    } else if (available < updated) {\n      statusMsg = `Waiting for rollout: ${available} out of ${updated} updated replicas available...`\n      out.state = \"deploying\"\n    }\n  }\n\n  out.lastMessage = statusMsg\n\n  return out\n}\n\n/**\n * Check if the specified Kubernetes objects are deployed and fully rolled out\n */\nexport async function checkObjectStatus(\n  api: KubeApi, namespace: string, objects: KubernetesObject[], prevStatuses?: RolloutStatus[],\n) {\n  let ready = true\n\n  const statuses: RolloutStatus[] = await Bluebird.map(objects, async (obj, i) => {\n    const handler = objHandlers[obj.kind]\n    const prevStatus = prevStatuses && prevStatuses[i]\n    const status: RolloutStatus = handler\n      ? await handler(api, namespace, obj, prevStatus && prevStatus.resourceVersion)\n      // if there is no explicit handler to check the status, we assume there's no rollout phase to wait for\n      : { state: \"ready\", obj }\n\n    if (status.state !== \"ready\") {\n      ready = false\n    }\n\n    return status\n  })\n\n  return { ready, statuses }\n}\n\ninterface WaitParams {\n  ctx: PluginContext,\n  provider: KubernetesProvider,\n  service: Service,\n  objects: KubernetesObject[],\n  logEntry?: LogEntry,\n}\n\n/**\n * Wait until the rollout is complete for each of the given Kubernetes objects\n */\nexport async function waitForObjects({ ctx, provider, service, objects, logEntry }: WaitParams) {\n  let loops = 0\n  let lastMessage\n  const startTime = new Date().getTime()\n\n  logEntry && logEntry.verbose({\n    symbol: \"info\",\n    section: service.name,\n    msg: `Waiting for service to be ready...`,\n  })\n\n  const api = new KubeApi(provider)\n  const namespace = await getAppNamespace(ctx, provider)\n  let prevStatuses: RolloutStatus[] = objects.map((obj) => ({\n    state: <ServiceState>\"unknown\",\n    obj,\n  }))\n\n  while (true) {\n    await sleep(2000 + 1000 * loops)\n\n    const { ready, statuses } = await checkObjectStatus(api, namespace, objects, prevStatuses)\n\n    for (const status of statuses) {\n      if (status.lastError) {\n        throw new DeploymentError(`Error deploying ${service.name}: ${status.lastError}`, {\n          serviceName: service.name,\n          status,\n        })\n      }\n\n      if (status.lastMessage && (!lastMessage || status.lastMessage !== lastMessage)) {\n        lastMessage = status.lastMessage\n        logEntry && logEntry.verbose({\n          symbol: \"info\",\n          section: service.name,\n          msg: status.lastMessage,\n        })\n      }\n    }\n\n    prevStatuses = statuses\n\n    if (ready) {\n      break\n    }\n\n    const now = new Date().getTime()\n\n    if (now - startTime > KUBECTL_DEFAULT_TIMEOUT * 1000) {\n      throw new Error(`Timed out waiting for ${service.name} to deploy`)\n    }\n  }\n\n  logEntry && logEntry.verbose({ symbol: \"info\", section: service.name, msg: `Service deployed` })\n}\n\n/**\n * Check if each of the given Kubernetes objects matches what's installed in the cluster\n */\nexport async function compareDeployedObjects(ctx: PluginContext, objects: KubernetesObject[]): Promise<boolean> {\n  const existingObjects = await Bluebird.map(objects, obj => getDeployedObject(ctx, ctx.provider, obj))\n\n  for (let [obj, existingSpec] of zip(objects, existingObjects)) {\n    if (existingSpec && obj) {\n      // the API version may implicitly change when deploying\n      existingSpec.apiVersion = obj.apiVersion\n\n      // the namespace property is silently dropped when added to non-namespaced\n      if (obj.metadata.namespace && existingSpec.metadata.namespace === undefined) {\n        delete obj.metadata.namespace\n      }\n\n      if (!existingSpec.metadata.annotations) {\n        existingSpec.metadata.annotations = {}\n      }\n\n      // handle auto-filled properties (this is a bit of a design issue in the K8s API)\n      if (obj.kind === \"Service\" && obj.spec.clusterIP === \"\") {\n        delete obj.spec.clusterIP\n      }\n\n      // handle properties that are omitted in the response because they have the default value\n      // (another design issue in the K8s API)\n      // NOTE: this approach won't fly in the long run, but hopefully we can climb out of this mess when\n      //       `kubectl diff` is ready, or server-side apply/diff is ready\n      if (obj.kind === \"DaemonSet\") {\n        if (obj.spec.minReadySeconds === 0) {\n          delete obj.spec.minReadySeconds\n        }\n        if (obj.spec.template.spec.hostNetwork === false) {\n          delete obj.spec.template.spec.hostNetwork\n        }\n      }\n\n      // clean null values\n      obj = <KubernetesObject>removeNull(obj)\n    }\n\n    if (!existingSpec || !isSubset(existingSpec, obj)) {\n      // console.log(JSON.stringify(obj, null, 4))\n      // console.log(JSON.stringify(existingSpec, null, 4))\n      // console.log(\"----------------------------------------------------\")\n      // throw new Error(\"bla\")\n      return false\n    }\n  }\n\n  return true\n}\n\nasync function getDeployedObject(ctx: PluginContext, provider: KubernetesProvider, obj: KubernetesObject) {\n  const api = new KubeApi(provider)\n  const namespace = obj.metadata.namespace || await getAppNamespace(ctx, provider)\n\n  try {\n    const res = await api.readBySpec(namespace, obj)\n    return res.body\n  } catch (err) {\n    if (err.code === 404) {\n      return null\n    } else {\n      throw err\n    }\n  }\n}\n\n/**\n * Recursively removes all null value properties from objects\n */\nexport function removeNull<T>(value: T | Iterable<T>): T | Iterable<T> | { [K in keyof T]: T[K] } {\n  if (isArray(value)) {\n    return value.map(removeNull)\n  } else if (isPlainObject(value)) {\n    return <{ [K in keyof T]: T[K] }>mapValues(pickBy(<any>value, v => v !== null), removeNull)\n  } else {\n    return value\n  }\n}\n"]} diff --git a/garden-service/build/plugins/kubernetes/system.d.ts b/garden-service/build/plugins/kubernetes/system.d.ts new file mode 100644 index 00000000000..40d23f2dab3 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/system.d.ts @@ -0,0 +1,7 @@ +import { Garden } from "../../garden"; +import { KubernetesProvider } from "./kubernetes"; +export declare const GARDEN_SYSTEM_NAMESPACE = "garden-system"; +export declare const systemSymbol: unique symbol; +export declare function isSystemGarden(provider: KubernetesProvider): boolean; +export declare function getSystemGarden(provider: KubernetesProvider): Promise; +//# sourceMappingURL=system.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/kubernetes/system.js b/garden-service/build/plugins/kubernetes/system.js new file mode 100644 index 00000000000..bae2ed37744 --- /dev/null +++ b/garden-service/build/plugins/kubernetes/system.js @@ -0,0 +1,64 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const constants_1 = require("../../constants"); +const garden_1 = require("../../garden"); +exports.GARDEN_SYSTEM_NAMESPACE = "garden-system"; +const systemProjectPath = path_1.join(constants_1.STATIC_DIR, "kubernetes", "system"); +exports.systemSymbol = Symbol(); +function isSystemGarden(provider) { + return provider.config._system === exports.systemSymbol; +} +exports.isSystemGarden = isSystemGarden; +function getSystemGarden(provider) { + return __awaiter(this, void 0, void 0, function* () { + return garden_1.Garden.factory(systemProjectPath, { + env: "default", + config: { + version: "0", + dirname: "system", + path: systemProjectPath, + project: { + name: "garden-system", + environmentDefaults: { + providers: [], + variables: {}, + }, + defaultEnvironment: "default", + environments: [ + { + name: "default", + providers: [ + { + name: "local-kubernetes", + context: provider.config.context, + namespace: exports.GARDEN_SYSTEM_NAMESPACE, + _system: exports.systemSymbol, + }, + ], + variables: {}, + }, + ], + }, + }, + }); + }); +} +exports.getSystemGarden = getSystemGarden; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/plugins/local/local-docker-swarm.d.ts b/garden-service/build/plugins/local/local-docker-swarm.d.ts new file mode 100644 index 00000000000..a84cbe3d56c --- /dev/null +++ b/garden-service/build/plugins/local/local-docker-swarm.d.ts @@ -0,0 +1,3 @@ +import { GardenPlugin } from "../../types/plugin/plugin"; +export declare const gardenPlugin: () => GardenPlugin; +//# sourceMappingURL=local-docker-swarm.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/local/local-docker-swarm.js b/garden-service/build/plugins/local/local-docker-swarm.js new file mode 100644 index 00000000000..51a98c6f456 --- /dev/null +++ b/garden-service/build/plugins/local/local-docker-swarm.js @@ -0,0 +1,302 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Docker = require("dockerode"); +const child_process_promise_1 = require("child-process-promise"); +const exceptions_1 = require("../../exceptions"); +const container_1 = require("../container"); +const lodash_1 = require("lodash"); +const util_1 = require("../../util/util"); +// should this be configurable and/or global across providers? +const DEPLOY_TIMEOUT = 30; +const pluginName = "local-docker-swarm"; +exports.gardenPlugin = () => ({ + actions: { + getEnvironmentStatus, + prepareEnvironment, + }, + moduleActions: { + container: { + getServiceStatus, + deployService({ ctx, module, service, runtimeContext, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: split this method up and test + const { versionString } = service.module.version; + logEntry && logEntry.info({ section: service.name, msg: `Deploying version ${versionString}` }); + const identifier = yield container_1.helpers.getLocalImageId(module); + const ports = service.spec.ports.map(p => { + const port = { + Protocol: p.protocol ? p.protocol.toLowerCase() : "tcp", + TargetPort: p.containerPort, + }; + if (p.hostPort) { + port.PublishedPort = p.hostPort; + } + }); + const envVars = lodash_1.map(Object.assign({}, runtimeContext.envVars, service.spec.env), (v, k) => `${k}=${v}`); + const volumeMounts = service.spec.volumes.map(v => { + // TODO-LOW: Support named volumes + if (v.hostPath) { + return { + Type: "bind", + Source: v.hostPath, + Target: v.containerPath, + }; + } + else { + return { + Type: "tmpfs", + Target: v.containerPath, + }; + } + }); + const opts = { + Name: getSwarmServiceName(ctx, service.name), + Labels: { + environment: ctx.environment.name, + provider: pluginName, + }, + TaskTemplate: { + ContainerSpec: { + Image: identifier, + Command: service.spec.command, + Env: envVars, + Mounts: volumeMounts, + }, + Resources: { + Limits: {}, + Reservations: {}, + }, + RestartPolicy: {}, + Placement: {}, + }, + Mode: { + Replicated: { + Replicas: 1, + }, + }, + UpdateConfig: { + Parallelism: 1, + }, + IngressSpec: { + Ports: ports, + }, + }; + const docker = getDocker(); + const serviceStatus = yield getServiceStatus({ ctx, service, module, runtimeContext, logEntry }); + let swarmServiceStatus; + let serviceId; + if (serviceStatus.providerId) { + const swarmService = yield docker.getService(serviceStatus.providerId); + swarmServiceStatus = yield swarmService.inspect(); + opts.version = parseInt(swarmServiceStatus.Version.Index, 10); + logEntry && logEntry.verbose({ + section: service.name, + msg: `Updating existing Swarm service (version ${opts.version})`, + }); + yield swarmService.update(opts); + serviceId = serviceStatus.providerId; + } + else { + logEntry && logEntry.verbose({ + section: service.name, + msg: `Creating new Swarm service`, + }); + const swarmService = yield docker.createService(opts); + serviceId = swarmService.ID; + } + // Wait for service to be ready + const start = new Date().getTime(); + while (true) { + yield util_1.sleep(1000); + const { lastState, lastError } = yield getServiceState(serviceId); + if (lastError) { + throw new exceptions_1.DeploymentError(`Service ${service.name} ${lastState}: ${lastError}`, { + service, + state: lastState, + error: lastError, + }); + } + if (mapContainerState(lastState) === "ready") { + break; + } + if (new Date().getTime() - start > DEPLOY_TIMEOUT * 1000) { + throw new exceptions_1.DeploymentError(`Timed out deploying ${service.name} (status: ${lastState}`, { + service, + state: lastState, + }); + } + } + logEntry && logEntry.info({ + section: service.name, + msg: `Ready`, + }); + return getServiceStatus({ ctx, module, service, runtimeContext, logEntry }); + }); + }, + getServiceOutputs({ ctx, service }) { + return __awaiter(this, void 0, void 0, function* () { + return { + host: getSwarmServiceName(ctx, service.name), + }; + }); + }, + execInService({ ctx, service, command, runtimeContext, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const status = yield getServiceStatus({ + ctx, + service, + module: service.module, + runtimeContext, + logEntry, + }); + if (!status.state || status.state !== "ready") { + throw new exceptions_1.DeploymentError(`Service ${service.name} is not running`, { + name: service.name, + state: status.state, + }); + } + // This is ugly, but dockerode doesn't have this, or at least it's too cumbersome to implement. + const swarmServiceName = getSwarmServiceName(ctx, service.name); + const servicePsCommand = [ + "docker", "service", "ps", + "-f", `'name=${swarmServiceName}.1'`, + "-f", `'desired-state=running'`, + swarmServiceName, + "-q", + ]; + let res = yield child_process_promise_1.exec(servicePsCommand.join(" ")); + const serviceContainerId = `${swarmServiceName}.1.${res.stdout.trim()}`; + const execCommand = ["docker", "exec", serviceContainerId, ...command]; + res = yield child_process_promise_1.exec(execCommand.join(" ")); + return { code: 0, output: "", stdout: res.stdout, stderr: res.stderr }; + }); + }, + }, + }, +}); +function getEnvironmentStatus() { + return __awaiter(this, void 0, void 0, function* () { + const docker = getDocker(); + try { + yield docker.swarmInspect(); + return { + ready: true, + }; + } + catch (err) { + if (err.statusCode === 503) { + // swarm has not been initialized + return { + ready: false, + services: [], + }; + } + else { + throw err; + } + } + }); +} +function prepareEnvironment() { + return __awaiter(this, void 0, void 0, function* () { + yield getDocker().swarmInit({}); + return {}; + }); +} +function getServiceStatus({ ctx, service }) { + return __awaiter(this, void 0, void 0, function* () { + const docker = getDocker(); + const swarmServiceName = getSwarmServiceName(ctx, service.name); + const swarmService = docker.getService(swarmServiceName); + let swarmServiceStatus; + try { + swarmServiceStatus = yield swarmService.inspect(); + } + catch (err) { + if (err.statusCode === 404) { + // service does not exist + return {}; + } + else { + throw err; + } + } + const image = swarmServiceStatus.Spec.TaskTemplate.ContainerSpec.Image; + const version = image.split(":")[1]; + const { lastState, lastError } = yield getServiceState(swarmServiceStatus.ID); + return { + providerId: swarmServiceStatus.ID, + version, + runningReplicas: swarmServiceStatus.Spec.Mode.Replicated.Replicas, + state: mapContainerState(lastState), + lastError: lastError || undefined, + createdAt: swarmServiceStatus.CreatedAt, + updatedAt: swarmServiceStatus.UpdatedAt, + }; + }); +} +function getDocker() { + return new Docker(); +} +// see schema in https://docs.docker.com/engine/api/v1.35/#operation/TaskList +const taskStateMap = { + new: "deploying", + allocated: "deploying", + pending: "deploying", + assigned: "deploying", + accepted: "deploying", + preparing: "deploying", + starting: "deploying", + running: "ready", + ready: "ready", + complete: "stopped", + shutdown: "stopped", + failed: "unhealthy", + rejected: "unhealthy", +}; +function mapContainerState(lastState) { + return lastState ? taskStateMap[lastState] : undefined; +} +function getSwarmServiceName(ctx, serviceName) { + return `${ctx.projectName}--${serviceName}`; +} +function getServiceTask(serviceId) { + return __awaiter(this, void 0, void 0, function* () { + let tasks = yield getDocker().listTasks({ + // Service: this.getSwarmServiceName(service.name), + }); + // For whatever (presumably totally reasonable) reason, the filter option above does not work. + tasks = tasks.filter(t => t.ServiceID === serviceId); + tasks = lodash_1.sortBy(tasks, ["CreatedAt"]).reverse(); + return tasks[0]; + }); +} +function getServiceState(serviceId) { + return __awaiter(this, void 0, void 0, function* () { + const task = yield getServiceTask(serviceId); + let lastState; + let lastError; + if (task) { + lastState = task.Status.State; + lastError = task.Status.Err || null; + } + return { lastState, lastError }; + }); +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/local/local-docker-swarm.ts"],"names":[],"mappings":"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","file":"plugins/local/local-docker-swarm.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Docker from \"dockerode\"\nimport { exec } from \"child-process-promise\"\nimport { DeploymentError } from \"../../exceptions\"\nimport { PluginContext } from \"../../plugin-context\"\nimport {\n  GardenPlugin,\n} from \"../../types/plugin/plugin\"\nimport {\n  DeployServiceParams,\n  ExecInServiceParams,\n  GetServiceOutputsParams,\n  GetServiceStatusParams,\n} from \"../../types/plugin/params\"\nimport {\n  helpers,\n  ContainerModule,\n} from \"../container\"\nimport {\n  map,\n  sortBy,\n} from \"lodash\"\nimport { sleep } from \"../../util/util\"\nimport { ServiceState, ServiceStatus } from \"../../types/service\"\n\n// should this be configurable and/or global across providers?\nconst DEPLOY_TIMEOUT = 30\n\nconst pluginName = \"local-docker-swarm\"\n\nexport const gardenPlugin = (): GardenPlugin => ({\n  actions: {\n    getEnvironmentStatus,\n    prepareEnvironment,\n  },\n  moduleActions: {\n    container: {\n      getServiceStatus,\n\n      async deployService(\n        { ctx, module, service, runtimeContext, logEntry }: DeployServiceParams<ContainerModule>,\n      ) {\n        // TODO: split this method up and test\n        const { versionString } = service.module.version\n\n        logEntry && logEntry.info({ section: service.name, msg: `Deploying version ${versionString}` })\n\n        const identifier = await helpers.getLocalImageId(module)\n        const ports = service.spec.ports.map(p => {\n          const port: any = {\n            Protocol: p.protocol ? p.protocol.toLowerCase() : \"tcp\",\n            TargetPort: p.containerPort,\n          }\n\n          if (p.hostPort) {\n            port.PublishedPort = p.hostPort\n          }\n        })\n\n        const envVars = map({ ...runtimeContext.envVars, ...service.spec.env }, (v, k) => `${k}=${v}`)\n\n        const volumeMounts = service.spec.volumes.map(v => {\n          // TODO-LOW: Support named volumes\n          if (v.hostPath) {\n            return {\n              Type: \"bind\",\n              Source: v.hostPath,\n              Target: v.containerPath,\n            }\n          } else {\n            return {\n              Type: \"tmpfs\",\n              Target: v.containerPath,\n            }\n          }\n        })\n\n        const opts: any = {\n          Name: getSwarmServiceName(ctx, service.name),\n          Labels: {\n            environment: ctx.environment.name,\n            provider: pluginName,\n          },\n          TaskTemplate: {\n            ContainerSpec: {\n              Image: identifier,\n              Command: service.spec.command,\n              Env: envVars,\n              Mounts: volumeMounts,\n            },\n            Resources: {\n              Limits: {},\n              Reservations: {},\n            },\n            RestartPolicy: {},\n            Placement: {},\n          },\n          Mode: {\n            Replicated: {\n              Replicas: 1,\n            },\n          },\n          UpdateConfig: {\n            Parallelism: 1,\n          },\n          IngressSpec: {\n            Ports: ports,\n          },\n        }\n\n        const docker = getDocker()\n        const serviceStatus = await getServiceStatus({ ctx, service, module, runtimeContext, logEntry })\n        let swarmServiceStatus\n        let serviceId\n\n        if (serviceStatus.providerId) {\n          const swarmService = await docker.getService(serviceStatus.providerId)\n          swarmServiceStatus = await swarmService.inspect()\n          opts.version = parseInt(swarmServiceStatus.Version.Index, 10)\n          logEntry && logEntry.verbose({\n            section: service.name,\n            msg: `Updating existing Swarm service (version ${opts.version})`,\n          })\n          await swarmService.update(opts)\n          serviceId = serviceStatus.providerId\n        } else {\n          logEntry && logEntry.verbose({\n            section: service.name,\n            msg: `Creating new Swarm service`,\n          })\n          const swarmService = await docker.createService(opts)\n          serviceId = swarmService.ID\n        }\n\n        // Wait for service to be ready\n        const start = new Date().getTime()\n\n        while (true) {\n          await sleep(1000)\n\n          const { lastState, lastError } = await getServiceState(serviceId)\n\n          if (lastError) {\n            throw new DeploymentError(`Service ${service.name} ${lastState}: ${lastError}`, {\n              service,\n              state: lastState,\n              error: lastError,\n            })\n          }\n\n          if (mapContainerState(lastState) === \"ready\") {\n            break\n          }\n\n          if (new Date().getTime() - start > DEPLOY_TIMEOUT * 1000) {\n            throw new DeploymentError(`Timed out deploying ${service.name} (status: ${lastState}`, {\n              service,\n              state: lastState,\n            })\n          }\n        }\n\n        logEntry && logEntry.info({\n          section: service.name,\n          msg: `Ready`,\n        })\n\n        return getServiceStatus({ ctx, module, service, runtimeContext, logEntry })\n      },\n\n      async getServiceOutputs({ ctx, service }: GetServiceOutputsParams<ContainerModule>) {\n        return {\n          host: getSwarmServiceName(ctx, service.name),\n        }\n      },\n\n      async execInService(\n        { ctx, service, command, runtimeContext, logEntry }: ExecInServiceParams<ContainerModule>,\n      ) {\n        const status = await getServiceStatus({\n          ctx,\n          service,\n          module: service.module,\n          runtimeContext,\n          logEntry,\n        })\n\n        if (!status.state || status.state !== \"ready\") {\n          throw new DeploymentError(`Service ${service.name} is not running`, {\n            name: service.name,\n            state: status.state,\n          })\n        }\n\n        // This is ugly, but dockerode doesn't have this, or at least it's too cumbersome to implement.\n        const swarmServiceName = getSwarmServiceName(ctx, service.name)\n        const servicePsCommand = [\n          \"docker\", \"service\", \"ps\",\n          \"-f\", `'name=${swarmServiceName}.1'`,\n          \"-f\", `'desired-state=running'`,\n          swarmServiceName,\n          \"-q\",\n        ]\n        let res = await exec(servicePsCommand.join(\" \"))\n        const serviceContainerId = `${swarmServiceName}.1.${res.stdout.trim()}`\n\n        const execCommand = [\"docker\", \"exec\", serviceContainerId, ...command]\n        res = await exec(execCommand.join(\" \"))\n\n        return { code: 0, output: \"\", stdout: res.stdout, stderr: res.stderr }\n      },\n    },\n  },\n})\n\nasync function getEnvironmentStatus() {\n  const docker = getDocker()\n\n  try {\n    await docker.swarmInspect()\n\n    return {\n      ready: true,\n    }\n  } catch (err) {\n    if (err.statusCode === 503) {\n      // swarm has not been initialized\n      return {\n        ready: false,\n        services: [],\n      }\n    } else {\n      throw err\n    }\n  }\n}\n\nasync function prepareEnvironment() {\n  await getDocker().swarmInit({})\n  return {}\n}\n\nasync function getServiceStatus({ ctx, service }: GetServiceStatusParams<ContainerModule>): Promise<ServiceStatus> {\n  const docker = getDocker()\n  const swarmServiceName = getSwarmServiceName(ctx, service.name)\n  const swarmService = docker.getService(swarmServiceName)\n\n  let swarmServiceStatus\n\n  try {\n    swarmServiceStatus = await swarmService.inspect()\n  } catch (err) {\n    if (err.statusCode === 404) {\n      // service does not exist\n      return {}\n    } else {\n      throw err\n    }\n  }\n\n  const image = swarmServiceStatus.Spec.TaskTemplate.ContainerSpec.Image\n  const version = image.split(\":\")[1]\n\n  const { lastState, lastError } = await getServiceState(swarmServiceStatus.ID)\n\n  return {\n    providerId: swarmServiceStatus.ID,\n    version,\n    runningReplicas: swarmServiceStatus.Spec.Mode.Replicated.Replicas,\n    state: mapContainerState(lastState),\n    lastError: lastError || undefined,\n    createdAt: swarmServiceStatus.CreatedAt,\n    updatedAt: swarmServiceStatus.UpdatedAt,\n  }\n}\n\nfunction getDocker() {\n  return new Docker()\n}\n\n// see schema in https://docs.docker.com/engine/api/v1.35/#operation/TaskList\nconst taskStateMap: { [key: string]: ServiceState } = {\n  new: \"deploying\",\n  allocated: \"deploying\",\n  pending: \"deploying\",\n  assigned: \"deploying\",\n  accepted: \"deploying\",\n  preparing: \"deploying\",\n  starting: \"deploying\",\n  running: \"ready\",\n  ready: \"ready\",\n  complete: \"stopped\",\n  shutdown: \"stopped\",\n  failed: \"unhealthy\",\n  rejected: \"unhealthy\",\n}\n\nfunction mapContainerState(lastState: string | undefined): ServiceState | undefined {\n  return lastState ? taskStateMap[lastState] : undefined\n}\n\nfunction getSwarmServiceName(ctx: PluginContext, serviceName: string) {\n  return `${ctx.projectName}--${serviceName}`\n}\n\nasync function getServiceTask(serviceId: string) {\n  let tasks = await getDocker().listTasks({\n    // Service: this.getSwarmServiceName(service.name),\n  })\n  // For whatever (presumably totally reasonable) reason, the filter option above does not work.\n  tasks = tasks.filter(t => t.ServiceID === serviceId)\n  tasks = sortBy(tasks, [\"CreatedAt\"]).reverse()\n\n  return tasks[0]\n}\n\nasync function getServiceState(serviceId: string) {\n  const task = await getServiceTask(serviceId)\n\n  let lastState\n  let lastError\n\n  if (task) {\n    lastState = task.Status.State\n    lastError = task.Status.Err || null\n  }\n\n  return { lastState, lastError }\n}\n"]} diff --git a/garden-service/build/plugins/local/local-google-cloud-functions.d.ts b/garden-service/build/plugins/local/local-google-cloud-functions.d.ts new file mode 100644 index 00000000000..57dc9b1c48b --- /dev/null +++ b/garden-service/build/plugins/local/local-google-cloud-functions.d.ts @@ -0,0 +1,3 @@ +import { GardenPlugin } from "../../types/plugin/plugin"; +export declare const gardenPlugin: () => GardenPlugin; +//# sourceMappingURL=local-google-cloud-functions.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/local/local-google-cloud-functions.js b/garden-service/build/plugins/local/local-google-cloud-functions.js new file mode 100644 index 00000000000..bdabc119d98 --- /dev/null +++ b/garden-service/build/plugins/local/local-google-cloud-functions.js @@ -0,0 +1,102 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const google_cloud_functions_1 = require("../google/google-cloud-functions"); +const constants_1 = require("../../constants"); +const pluginName = "local-google-cloud-functions"; +const emulatorModuleName = "local-gcf-container"; +const baseContainerName = `${pluginName}--${emulatorModuleName}`; +const emulatorBaseModulePath = path_1.join(constants_1.STATIC_DIR, emulatorModuleName); +const emulatorPort = 8010; +exports.gardenPlugin = () => ({ + modules: [emulatorBaseModulePath], + moduleActions: { + "google-cloud-function": { + validate(params) { + return __awaiter(this, void 0, void 0, function* () { + const parsed = yield google_cloud_functions_1.parseGcfModule(params); + // convert the module and services to containers to run locally + const serviceConfigs = parsed.serviceConfigs.map((s) => { + const functionEntrypoint = s.spec.entrypoint || s.name; + const spec = { + name: s.name, + dependencies: s.dependencies, + outputs: { + ingress: `http://${s.name}:${emulatorPort}/local/local/${functionEntrypoint}`, + }, + command: ["/app/start.sh", functionEntrypoint], + daemon: false, + ingresses: [{ + name: "default", + hostname: s.spec.hostname, + port: "http", + path: "/", + }], + env: {}, + healthCheck: { tcpPort: "http" }, + ports: [ + { + name: "http", + protocol: "TCP", + containerPort: emulatorPort, + }, + ], + volumes: [], + }; + return { + name: spec.name, + dependencies: spec.dependencies, + outputs: spec.outputs, + spec, + }; + }); + return { + allowPublish: true, + build: { + command: [], + dependencies: parsed.build.dependencies.concat([{ + name: emulatorModuleName, + plugin: pluginName, + copy: [{ + source: "child/Dockerfile", + target: "Dockerfile", + }], + }]), + }, + name: parsed.name, + path: parsed.path, + type: "container", + variables: parsed.variables, + spec: { + buildArgs: { + baseImageName: `${baseContainerName}:\${modules.${baseContainerName}.version}`, + }, + image: `${parsed.name}:\${modules.${parsed.name}.version}`, + services: serviceConfigs.map(s => s.spec), + tests: [], + }, + serviceConfigs, + testConfigs: parsed.testConfigs, + }; + }); + }, + }, + }, +}); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBsdWdpbnMvbG9jYWwvbG9jYWwtZ29vZ2xlLWNsb3VkLWZ1bmN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7O0FBR0gsK0JBQTJCO0FBQzNCLDZFQUd5QztBQUl6QywrQ0FBNEM7QUFPNUMsTUFBTSxVQUFVLEdBQUcsOEJBQThCLENBQUE7QUFDakQsTUFBTSxrQkFBa0IsR0FBRyxxQkFBcUIsQ0FBQTtBQUNoRCxNQUFNLGlCQUFpQixHQUFHLEdBQUcsVUFBVSxLQUFLLGtCQUFrQixFQUFFLENBQUE7QUFDaEUsTUFBTSxzQkFBc0IsR0FBRyxXQUFJLENBQUMsc0JBQVUsRUFBRSxrQkFBa0IsQ0FBQyxDQUFBO0FBQ25FLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQTtBQUVaLFFBQUEsWUFBWSxHQUFHLEdBQWlCLEVBQUUsQ0FBQyxDQUFDO0lBQy9DLE9BQU8sRUFBRSxDQUFDLHNCQUFzQixDQUFDO0lBRWpDLGFBQWEsRUFBRTtRQUNiLHVCQUF1QixFQUFFO1lBQ2pCLFFBQVEsQ0FBQyxNQUF1Qzs7b0JBQ3BELE1BQU0sTUFBTSxHQUFHLE1BQU0sdUNBQWMsQ0FBQyxNQUFNLENBQUMsQ0FBQTtvQkFFM0MsK0RBQStEO29CQUMvRCxNQUFNLGNBQWMsR0FBMEMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRTt3QkFDNUYsTUFBTSxrQkFBa0IsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLFVBQVUsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFBO3dCQUV0RCxNQUFNLElBQUksR0FBRzs0QkFDWCxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUk7NEJBQ1osWUFBWSxFQUFFLENBQUMsQ0FBQyxZQUFZOzRCQUM1QixPQUFPLEVBQUU7Z0NBQ1AsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDLElBQUksSUFBSSxZQUFZLGdCQUFnQixrQkFBa0IsRUFBRTs2QkFDOUU7NEJBQ0QsT0FBTyxFQUFFLENBQUMsZUFBZSxFQUFFLGtCQUFrQixDQUFDOzRCQUM5QyxNQUFNLEVBQUUsS0FBSzs0QkFDYixTQUFTLEVBQUUsQ0FBQztvQ0FDVixJQUFJLEVBQUUsU0FBUztvQ0FDZixRQUFRLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxRQUFRO29DQUN6QixJQUFJLEVBQUUsTUFBTTtvQ0FDWixJQUFJLEVBQUUsR0FBRztpQ0FDVixDQUFDOzRCQUNGLEdBQUcsRUFBRSxFQUFFOzRCQUNQLFdBQVcsRUFBRSxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUU7NEJBQ2hDLEtBQUssRUFBRTtnQ0FDTDtvQ0FDRSxJQUFJLEVBQUUsTUFBTTtvQ0FDWixRQUFRLEVBQXVCLEtBQUs7b0NBQ3BDLGFBQWEsRUFBRSxZQUFZO2lDQUM1Qjs2QkFDRjs0QkFDRCxPQUFPLEVBQUUsRUFBRTt5QkFDWixDQUFBO3dCQUVELE9BQU87NEJBQ0wsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJOzRCQUNmLFlBQVksRUFBRSxJQUFJLENBQUMsWUFBWTs0QkFDL0IsT0FBTyxFQUFFLElBQUksQ0FBQyxPQUFPOzRCQUNyQixJQUFJO3lCQUNMLENBQUE7b0JBQ0gsQ0FBQyxDQUFDLENBQUE7b0JBRUYsT0FBTzt3QkFDTCxZQUFZLEVBQUUsSUFBSTt3QkFDbEIsS0FBSyxFQUFFOzRCQUNMLE9BQU8sRUFBRSxFQUFFOzRCQUNYLFlBQVksRUFBRSxNQUFNLENBQUMsS0FBSyxDQUFDLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQztvQ0FDOUMsSUFBSSxFQUFFLGtCQUFrQjtvQ0FDeEIsTUFBTSxFQUFFLFVBQVU7b0NBQ2xCLElBQUksRUFBRSxDQUFDOzRDQUNMLE1BQU0sRUFBRSxrQkFBa0I7NENBQzFCLE1BQU0sRUFBRSxZQUFZO3lDQUNyQixDQUFDO2lDQUNILENBQUMsQ0FBQzt5QkFDSjt3QkFDRCxJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUk7d0JBQ2pCLElBQUksRUFBRSxNQUFNLENBQUMsSUFBSTt3QkFDakIsSUFBSSxFQUFFLFdBQVc7d0JBQ2pCLFNBQVMsRUFBRSxNQUFNLENBQUMsU0FBUzt3QkFFM0IsSUFBSSxFQUFFOzRCQUNKLFNBQVMsRUFBRTtnQ0FDVCxhQUFhLEVBQUUsR0FBRyxpQkFBaUIsZUFBZSxpQkFBaUIsV0FBVzs2QkFDL0U7NEJBQ0QsS0FBSyxFQUFFLEdBQUcsTUFBTSxDQUFDLElBQUksZUFBZSxNQUFNLENBQUMsSUFBSSxXQUFXOzRCQUMxRCxRQUFRLEVBQUUsY0FBYyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUF1QixDQUFDLENBQUMsSUFBSSxDQUFDOzRCQUMvRCxLQUFLLEVBQUUsRUFBRTt5QkFDVjt3QkFFRCxjQUFjO3dCQUNkLFdBQVcsRUFBRSxNQUFNLENBQUMsV0FBVztxQkFDaEMsQ0FBQTtnQkFDSCxDQUFDO2FBQUE7U0FDRjtLQUNGO0NBQ0YsQ0FBQyxDQUFBIiwiZmlsZSI6InBsdWdpbnMvbG9jYWwvbG9jYWwtZ29vZ2xlLWNsb3VkLWZ1bmN0aW9ucy5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKEMpIDIwMTggR2FyZGVuIFRlY2hub2xvZ2llcywgSW5jLiA8aW5mb0BnYXJkZW4uaW8+XG4gKlxuICogVGhpcyBTb3VyY2UgQ29kZSBGb3JtIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoZSBNb3ppbGxhIFB1YmxpY1xuICogTGljZW5zZSwgdi4gMi4wLiBJZiBhIGNvcHkgb2YgdGhlIE1QTCB3YXMgbm90IGRpc3RyaWJ1dGVkIHdpdGggdGhpc1xuICogZmlsZSwgWW91IGNhbiBvYnRhaW4gb25lIGF0IGh0dHA6Ly9tb3ppbGxhLm9yZy9NUEwvMi4wLy5cbiAqL1xuXG5pbXBvcnQgeyBWYWxpZGF0ZU1vZHVsZVBhcmFtcyB9IGZyb20gXCIuLi8uLi90eXBlcy9wbHVnaW4vcGFyYW1zXCJcbmltcG9ydCB7IGpvaW4gfSBmcm9tIFwicGF0aFwiXG5pbXBvcnQge1xuICBHY2ZNb2R1bGUsXG4gIHBhcnNlR2NmTW9kdWxlLFxufSBmcm9tIFwiLi4vZ29vZ2xlL2dvb2dsZS1jbG91ZC1mdW5jdGlvbnNcIlxuaW1wb3J0IHtcbiAgR2FyZGVuUGx1Z2luLFxufSBmcm9tIFwiLi4vLi4vdHlwZXMvcGx1Z2luL3BsdWdpblwiXG5pbXBvcnQgeyBTVEFUSUNfRElSIH0gZnJvbSBcIi4uLy4uL2NvbnN0YW50c1wiXG5pbXBvcnQgeyBTZXJ2aWNlQ29uZmlnIH0gZnJvbSBcIi4uLy4uL2NvbmZpZy9zZXJ2aWNlXCJcbmltcG9ydCB7XG4gIENvbnRhaW5lclNlcnZpY2VTcGVjLFxuICBTZXJ2aWNlUG9ydFByb3RvY29sLFxufSBmcm9tIFwiLi4vY29udGFpbmVyXCJcblxuY29uc3QgcGx1Z2luTmFtZSA9IFwibG9jYWwtZ29vZ2xlLWNsb3VkLWZ1bmN0aW9uc1wiXG5jb25zdCBlbXVsYXRvck1vZHVsZU5hbWUgPSBcImxvY2FsLWdjZi1jb250YWluZXJcIlxuY29uc3QgYmFzZUNvbnRhaW5lck5hbWUgPSBgJHtwbHVnaW5OYW1lfS0tJHtlbXVsYXRvck1vZHVsZU5hbWV9YFxuY29uc3QgZW11bGF0b3JCYXNlTW9kdWxlUGF0aCA9IGpvaW4oU1RBVElDX0RJUiwgZW11bGF0b3JNb2R1bGVOYW1lKVxuY29uc3QgZW11bGF0b3JQb3J0ID0gODAxMFxuXG5leHBvcnQgY29uc3QgZ2FyZGVuUGx1Z2luID0gKCk6IEdhcmRlblBsdWdpbiA9PiAoe1xuICBtb2R1bGVzOiBbZW11bGF0b3JCYXNlTW9kdWxlUGF0aF0sXG5cbiAgbW9kdWxlQWN0aW9uczoge1xuICAgIFwiZ29vZ2xlLWNsb3VkLWZ1bmN0aW9uXCI6IHtcbiAgICAgIGFzeW5jIHZhbGlkYXRlKHBhcmFtczogVmFsaWRhdGVNb2R1bGVQYXJhbXM8R2NmTW9kdWxlPikge1xuICAgICAgICBjb25zdCBwYXJzZWQgPSBhd2FpdCBwYXJzZUdjZk1vZHVsZShwYXJhbXMpXG5cbiAgICAgICAgLy8gY29udmVydCB0aGUgbW9kdWxlIGFuZCBzZXJ2aWNlcyB0byBjb250YWluZXJzIHRvIHJ1biBsb2NhbGx5XG4gICAgICAgIGNvbnN0IHNlcnZpY2VDb25maWdzOiBTZXJ2aWNlQ29uZmlnPENvbnRhaW5lclNlcnZpY2VTcGVjPltdID0gcGFyc2VkLnNlcnZpY2VDb25maWdzLm1hcCgocykgPT4ge1xuICAgICAgICAgIGNvbnN0IGZ1bmN0aW9uRW50cnlwb2ludCA9IHMuc3BlYy5lbnRyeXBvaW50IHx8IHMubmFtZVxuXG4gICAgICAgICAgY29uc3Qgc3BlYyA9IHtcbiAgICAgICAgICAgIG5hbWU6IHMubmFtZSxcbiAgICAgICAgICAgIGRlcGVuZGVuY2llczogcy5kZXBlbmRlbmNpZXMsXG4gICAgICAgICAgICBvdXRwdXRzOiB7XG4gICAgICAgICAgICAgIGluZ3Jlc3M6IGBodHRwOi8vJHtzLm5hbWV9OiR7ZW11bGF0b3JQb3J0fS9sb2NhbC9sb2NhbC8ke2Z1bmN0aW9uRW50cnlwb2ludH1gLFxuICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIGNvbW1hbmQ6IFtcIi9hcHAvc3RhcnQuc2hcIiwgZnVuY3Rpb25FbnRyeXBvaW50XSxcbiAgICAgICAgICAgIGRhZW1vbjogZmFsc2UsXG4gICAgICAgICAgICBpbmdyZXNzZXM6IFt7XG4gICAgICAgICAgICAgIG5hbWU6IFwiZGVmYXVsdFwiLFxuICAgICAgICAgICAgICBob3N0bmFtZTogcy5zcGVjLmhvc3RuYW1lLFxuICAgICAgICAgICAgICBwb3J0OiBcImh0dHBcIixcbiAgICAgICAgICAgICAgcGF0aDogXCIvXCIsXG4gICAgICAgICAgICB9XSxcbiAgICAgICAgICAgIGVudjoge30sXG4gICAgICAgICAgICBoZWFsdGhDaGVjazogeyB0Y3BQb3J0OiBcImh0dHBcIiB9LFxuICAgICAgICAgICAgcG9ydHM6IFtcbiAgICAgICAgICAgICAge1xuICAgICAgICAgICAgICAgIG5hbWU6IFwiaHR0cFwiLFxuICAgICAgICAgICAgICAgIHByb3RvY29sOiA8U2VydmljZVBvcnRQcm90b2NvbD5cIlRDUFwiLFxuICAgICAgICAgICAgICAgIGNvbnRhaW5lclBvcnQ6IGVtdWxhdG9yUG9ydCxcbiAgICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIF0sXG4gICAgICAgICAgICB2b2x1bWVzOiBbXSxcbiAgICAgICAgICB9XG5cbiAgICAgICAgICByZXR1cm4ge1xuICAgICAgICAgICAgbmFtZTogc3BlYy5uYW1lLFxuICAgICAgICAgICAgZGVwZW5kZW5jaWVzOiBzcGVjLmRlcGVuZGVuY2llcyxcbiAgICAgICAgICAgIG91dHB1dHM6IHNwZWMub3V0cHV0cyxcbiAgICAgICAgICAgIHNwZWMsXG4gICAgICAgICAgfVxuICAgICAgICB9KVxuXG4gICAgICAgIHJldHVybiB7XG4gICAgICAgICAgYWxsb3dQdWJsaXNoOiB0cnVlLFxuICAgICAgICAgIGJ1aWxkOiB7XG4gICAgICAgICAgICBjb21tYW5kOiBbXSxcbiAgICAgICAgICAgIGRlcGVuZGVuY2llczogcGFyc2VkLmJ1aWxkLmRlcGVuZGVuY2llcy5jb25jYXQoW3tcbiAgICAgICAgICAgICAgbmFtZTogZW11bGF0b3JNb2R1bGVOYW1lLFxuICAgICAgICAgICAgICBwbHVnaW46IHBsdWdpbk5hbWUsXG4gICAgICAgICAgICAgIGNvcHk6IFt7XG4gICAgICAgICAgICAgICAgc291cmNlOiBcImNoaWxkL0RvY2tlcmZpbGVcIixcbiAgICAgICAgICAgICAgICB0YXJnZXQ6IFwiRG9ja2VyZmlsZVwiLFxuICAgICAgICAgICAgICB9XSxcbiAgICAgICAgICAgIH1dKSxcbiAgICAgICAgICB9LFxuICAgICAgICAgIG5hbWU6IHBhcnNlZC5uYW1lLFxuICAgICAgICAgIHBhdGg6IHBhcnNlZC5wYXRoLFxuICAgICAgICAgIHR5cGU6IFwiY29udGFpbmVyXCIsXG4gICAgICAgICAgdmFyaWFibGVzOiBwYXJzZWQudmFyaWFibGVzLFxuXG4gICAgICAgICAgc3BlYzoge1xuICAgICAgICAgICAgYnVpbGRBcmdzOiB7XG4gICAgICAgICAgICAgIGJhc2VJbWFnZU5hbWU6IGAke2Jhc2VDb250YWluZXJOYW1lfTpcXCR7bW9kdWxlcy4ke2Jhc2VDb250YWluZXJOYW1lfS52ZXJzaW9ufWAsXG4gICAgICAgICAgICB9LFxuICAgICAgICAgICAgaW1hZ2U6IGAke3BhcnNlZC5uYW1lfTpcXCR7bW9kdWxlcy4ke3BhcnNlZC5uYW1lfS52ZXJzaW9ufWAsXG4gICAgICAgICAgICBzZXJ2aWNlczogc2VydmljZUNvbmZpZ3MubWFwKHMgPT4gPENvbnRhaW5lclNlcnZpY2VTcGVjPnMuc3BlYyksXG4gICAgICAgICAgICB0ZXN0czogW10sXG4gICAgICAgICAgfSxcblxuICAgICAgICAgIHNlcnZpY2VDb25maWdzLFxuICAgICAgICAgIHRlc3RDb25maWdzOiBwYXJzZWQudGVzdENvbmZpZ3MsXG4gICAgICAgIH1cbiAgICAgIH0sXG4gICAgfSxcbiAgfSxcbn0pXG4iXX0= diff --git a/garden-service/build/plugins/npm-package.d.ts b/garden-service/build/plugins/npm-package.d.ts new file mode 100644 index 00000000000..7b648972366 --- /dev/null +++ b/garden-service/build/plugins/npm-package.d.ts @@ -0,0 +1,3 @@ +import { GardenPlugin } from "../types/plugin/plugin"; +export declare const gardenPlugin: () => GardenPlugin; +//# sourceMappingURL=npm-package.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/npm-package.js b/garden-service/build/plugins/npm-package.js new file mode 100644 index 00000000000..e92817baa0d --- /dev/null +++ b/garden-service/build/plugins/npm-package.js @@ -0,0 +1,17 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const generic_1 = require("./generic"); +exports.gardenPlugin = () => ({ + moduleActions: { + "npm-package": generic_1.genericPlugin.moduleActions.generic, + }, +}); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBsdWdpbnMvbnBtLXBhY2thZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7QUFHSCx1Q0FFa0I7QUFFTCxRQUFBLFlBQVksR0FBRyxHQUFpQixFQUFFLENBQUMsQ0FBQztJQUMvQyxhQUFhLEVBQUU7UUFDYixhQUFhLEVBQUUsdUJBQWEsQ0FBQyxhQUFjLENBQUMsT0FBTztLQUNwRDtDQUNGLENBQUMsQ0FBQSIsImZpbGUiOiJwbHVnaW5zL25wbS1wYWNrYWdlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoQykgMjAxOCBHYXJkZW4gVGVjaG5vbG9naWVzLCBJbmMuIDxpbmZvQGdhcmRlbi5pbz5cbiAqXG4gKiBUaGlzIFNvdXJjZSBDb2RlIEZvcm0gaXMgc3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhlIE1vemlsbGEgUHVibGljXG4gKiBMaWNlbnNlLCB2LiAyLjAuIElmIGEgY29weSBvZiB0aGUgTVBMIHdhcyBub3QgZGlzdHJpYnV0ZWQgd2l0aCB0aGlzXG4gKiBmaWxlLCBZb3UgY2FuIG9idGFpbiBvbmUgYXQgaHR0cDovL21vemlsbGEub3JnL01QTC8yLjAvLlxuICovXG5cbmltcG9ydCB7IEdhcmRlblBsdWdpbiB9IGZyb20gXCIuLi90eXBlcy9wbHVnaW4vcGx1Z2luXCJcbmltcG9ydCB7XG4gIGdlbmVyaWNQbHVnaW4sXG59IGZyb20gXCIuL2dlbmVyaWNcIlxuXG5leHBvcnQgY29uc3QgZ2FyZGVuUGx1Z2luID0gKCk6IEdhcmRlblBsdWdpbiA9PiAoe1xuICBtb2R1bGVBY3Rpb25zOiB7XG4gICAgXCJucG0tcGFja2FnZVwiOiBnZW5lcmljUGx1Z2luLm1vZHVsZUFjdGlvbnMhLmdlbmVyaWMsXG4gIH0sXG59KVxuIl19 diff --git a/garden-service/build/plugins/openfaas/openfaas.d.ts b/garden-service/build/plugins/openfaas/openfaas.d.ts new file mode 100644 index 00000000000..aded883d2b7 --- /dev/null +++ b/garden-service/build/plugins/openfaas/openfaas.d.ts @@ -0,0 +1,29 @@ +import * as Joi from "joi"; +import { Garden } from "../../garden"; +import { PluginContext } from "../../plugin-context"; +import { Module } from "../../types/module"; +import { Service } from "../../types/service"; +import { GenericModuleSpec, GenericTestSpec } from "../generic"; +import { BaseServiceSpec } from "../../config/service"; +import { GardenPlugin } from "../../types/plugin/plugin"; +import { Provider } from "../../config/project"; +export declare const stackFilename = "stack.yml"; +export declare const FAAS_CLI_IMAGE_ID = "openfaas/faas-cli:0.7.3"; +export interface OpenFaasModuleSpec extends GenericModuleSpec { + handler: string; + image: string; + lang: string; +} +export declare const openfaasModuleSpecSchame: Joi.ObjectSchema; +export interface OpenFaasModule extends Module { +} +export interface OpenFaasService extends Service { +} +export interface OpenFaasConfig extends Provider { + hostname: string; +} +export declare function gardenPlugin({ config }: { + config: OpenFaasConfig; +}): GardenPlugin; +export declare function getOpenFaasGarden(ctx: PluginContext): Promise; +//# sourceMappingURL=openfaas.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/openfaas/openfaas.js b/garden-service/build/plugins/openfaas/openfaas.js new file mode 100644 index 00000000000..8bba465c48d --- /dev/null +++ b/garden-service/build/plugins/openfaas/openfaas.js @@ -0,0 +1,383 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const path_1 = require("path"); +const url_1 = require("url"); +const constants_1 = require("../../constants"); +const exceptions_1 = require("../../exceptions"); +const garden_1 = require("../../garden"); +const common_1 = require("../../config/common"); +const generic_1 = require("../generic"); +const namespace_1 = require("../kubernetes/namespace"); +const lodash_1 = require("lodash"); +const util_1 = require("../../util/util"); +const execa = require("execa"); +const api_1 = require("../kubernetes/api"); +const status_1 = require("../kubernetes/status"); +const system_1 = require("../kubernetes/system"); +const project_1 = require("../../config/project"); +const dedent = require("dedent"); +const systemProjectPath = path_1.join(constants_1.STATIC_DIR, "openfaas", "system"); +exports.stackFilename = "stack.yml"; +exports.FAAS_CLI_IMAGE_ID = "openfaas/faas-cli:0.7.3"; +exports.openfaasModuleSpecSchame = generic_1.genericModuleSpecSchema + .keys({ + dependencies: common_1.joiArray(Joi.string()) + .description("The names of services/functions that this function depends on at runtime."), + handler: Joi.string() + .default(".") + .uri({ relativeOnly: true }) + .description("Specify which directory under the module contains the handler file/function."), + image: Joi.string() + .description("The image name to use for the built OpenFaaS container (defaults to the module name)"), + lang: Joi.string() + .required() + .description("The OpenFaaS language template to use to build this function."), +}) + .unknown(false) + .description("The module specification for an OpenFaaS module."); +const configSchema = project_1.providerConfigBaseSchema + .keys({ + hostname: Joi.string() + .hostname() + .description(dedent ` + The hostname to configure for the function gateway. + Defaults to the default hostname of the configured Kubernetes provider. + + Important: If you have other types of services, this should be different from their ingress hostnames, + or the other services should not expose paths under /function and /system to avoid routing conflicts.`) + .example("functions.mydomain.com"), +}); +function gardenPlugin({ config }) { + config = common_1.validate(config, configSchema, { context: "OpenFaaS provider config" }); + return { + modules: [path_1.join(constants_1.STATIC_DIR, "openfaas", "builder")], + actions: { + getEnvironmentStatus({ ctx }) { + return __awaiter(this, void 0, void 0, function* () { + const ofGarden = yield getOpenFaasGarden(ctx); + const status = yield ofGarden.actions.getStatus(); + const envReady = lodash_1.every(lodash_1.values(status.providers).map(s => s.ready)); + const servicesReady = lodash_1.every(lodash_1.values(status.services).map(s => s.state === "ready")); + return { + ready: envReady && servicesReady, + detail: status, + }; + }); + }, + prepareEnvironment({ ctx, force }) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: refactor to dedupe similar code in local-kubernetes + const ofGarden = yield getOpenFaasGarden(ctx); + yield ofGarden.actions.prepareEnvironment({ force }); + const results = yield ofGarden.actions.deployServices({}); + const failed = lodash_1.values(results.taskResults).filter(r => !!r.error).length; + if (failed) { + throw new exceptions_1.PluginError(`openfaas: ${failed} errors occurred when configuring environment`, { + results, + }); + } + return {}; + }); + }, + cleanupEnvironment({ ctx }) { + return __awaiter(this, void 0, void 0, function* () { + const ofGarden = yield getOpenFaasGarden(ctx); + return ofGarden.actions.cleanupEnvironment({}); + }); + }, + }, + moduleActions: { + openfaas: { + validate({ moduleConfig }) { + return __awaiter(this, void 0, void 0, function* () { + moduleConfig.spec = common_1.validate(moduleConfig.spec, exports.openfaasModuleSpecSchame, { context: `module ${moduleConfig.name}` }); + moduleConfig.build.command = [ + "faas-cli", + "build", + "-f", exports.stackFilename, + ]; + moduleConfig.build.dependencies.push({ + name: "builder", + plugin: "openfaas", + copy: [{ + source: "*", + target: ".", + }], + }); + moduleConfig.serviceConfigs = [{ + dependencies: [], + name: moduleConfig.name, + outputs: {}, + spec: { + name: moduleConfig.name, + dependencies: [], + outputs: {}, + }, + }]; + moduleConfig.testConfigs = moduleConfig.spec.tests.map(t => ({ + name: t.name, + dependencies: t.dependencies, + spec: t, + timeout: t.timeout, + })); + return moduleConfig; + }); + }, + getBuildStatus: generic_1.getGenericModuleBuildStatus, + build(params) { + return __awaiter(this, void 0, void 0, function* () { + const { ctx, module } = params; + // prepare the stack.yml file, before handing off the build to the generic handler + yield writeStackFile(ctx, module, {}); + return generic_1.buildGenericModule(params); + }); + }, + // TODO: design and implement a proper test flow for openfaas functions + testModule: generic_1.testGenericModule, + getServiceStatus, + getServiceOutputs({ ctx, service }) { + return __awaiter(this, void 0, void 0, function* () { + return { + endpoint: yield getInternalServiceUrl(ctx, service), + }; + }); + }, + deployService(params) { + return __awaiter(this, void 0, void 0, function* () { + const { ctx, module, service, logEntry, runtimeContext } = params; + // write the stack file again with environment variables + yield writeStackFile(ctx, module, runtimeContext.envVars); + // use faas-cli to do the deployment + yield execa("faas-cli", ["deploy", "-f", exports.stackFilename], { cwd: module.buildPath }); + // wait until deployment is ready + const k8sProvider = getK8sProvider(ctx); + const namespace = yield namespace_1.getAppNamespace(ctx, k8sProvider); + const api = new api_1.KubeApi(k8sProvider); + const deployment = (yield api.apps.readNamespacedDeployment(service.name, namespace)).body; + yield status_1.waitForObjects({ ctx, provider: k8sProvider, service, logEntry, objects: [deployment] }); + // TODO: avoid duplicate work here + return getServiceStatus(params); + }); + }, + deleteService(params) { + return __awaiter(this, void 0, void 0, function* () { + const { ctx, logEntry, service, runtimeContext } = params; + let status; + let found = true; + try { + status = yield getServiceStatus({ + ctx, + service, + runtimeContext, + module: service.module, + }); + found = !!status.state; + yield execa("faas-cli", ["remove", "-f", exports.stackFilename], { cwd: service.module.buildPath }); + } + catch (err) { + found = false; + } + if (logEntry) { + found ? logEntry.setSuccess("Service deleted") : logEntry.setWarn("Service not deployed"); + } + return status; + }); + }, + }, + }, + }; +} +exports.gardenPlugin = gardenPlugin; +function writeStackFile(ctx, module, envVars) { + return __awaiter(this, void 0, void 0, function* () { + const image = getImageName(module); + const stackPath = path_1.join(module.buildPath, exports.stackFilename); + return util_1.dumpYaml(stackPath, { + provider: { + name: "faas", + gateway: getExternalGatewayUrl(ctx), + }, + functions: { + [module.name]: { + lang: module.spec.lang, + handler: module.spec.handler, + image, + environment: envVars, + }, + }, + }); + }); +} +function getServiceStatus({ ctx, service }) { + return __awaiter(this, void 0, void 0, function* () { + const k8sProvider = getK8sProvider(ctx); + const ingresses = [{ + hostname: getExternalGatewayHostname(ctx.provider, k8sProvider), + path: getServicePath(service), + port: k8sProvider.config.ingressHttpPort, + protocol: "http", + }]; + const namespace = yield namespace_1.getAppNamespace(ctx, k8sProvider); + const api = new api_1.KubeApi(k8sProvider); + let deployment; + try { + deployment = (yield api.apps.readNamespacedDeployment(service.name, namespace)).body; + } + catch (err) { + if (err.code === 404) { + return {}; + } + else { + throw err; + } + } + const container = util_1.findByName(deployment.spec.template.spec.containers, "hello-function"); + const version = util_1.findByName(container.env, "GARDEN_VERSION").value; + const status = yield status_1.checkDeploymentStatus(api, namespace, deployment); + return { + state: status.state, + version, + ingresses, + }; + }); +} +function getImageName(module) { + return `${module.name || module.spec.image}:${module.version.versionString}`; +} +// NOTE: we're currently not using the CRD/operator, but might change that in the future +// +// async function createFunctionObject(service: OpenFaasService, namespace: string): Promise { +// const image = await getImageName(service.module) +// return { +// apiVersion: "openfaas.com/v1alpha2", +// kind: "Function", +// metadata: { +// name: service.name, +// namespace, +// }, +// spec: { +// name: service.name, +// image, +// labels: { +// "com.openfaas.scale.min": "1", +// "com.openfaas.scale.max": "5", +// }, +// environment: { +// write_debug: "true", +// }, +// limits: { +// cpu: DEFAULT_CPU_LIMIT, +// memory: DEFAULT_MEMORY_LIMIT, +// }, +// requests: { +// cpu: DEFAULT_CPU_REQUEST, +// memory: DEFAULT_MEMORY_REQUEST, +// }, +// }, +// } +// } +function getK8sProvider(ctx) { + const provider = ctx.providers["local-kubernetes"] || ctx.providers.kubernetes; + if (!provider) { + throw new exceptions_1.ConfigurationError(`openfaas requires a kubernetes (or local-kubernetes) provider to be configured`, { + configuredProviders: Object.keys(ctx.providers), + }); + } + return provider; +} +function getServicePath(service) { + return path_1.join("/", "function", service.name); +} +function getInternalGatewayUrl(ctx) { + return __awaiter(this, void 0, void 0, function* () { + const k8sProvider = getK8sProvider(ctx); + const namespace = yield getOpenfaasNamespace(ctx, k8sProvider, true); + return `http://gateway.${namespace}.svc.cluster.local:8080`; + }); +} +function getExternalGatewayHostname(provider, k8sProvider) { + const hostname = provider.config.hostname || k8sProvider.config.defaultHostname; + if (!hostname) { + throw new exceptions_1.ConfigurationError(`openfaas: Must configure hostname if no default hostname is configured on Kubernetes provider.`, { + config: provider, + }); + } + return hostname; +} +function getExternalGatewayUrl(ctx) { + const k8sProvider = getK8sProvider(ctx); + const hostname = getExternalGatewayHostname(ctx.provider, k8sProvider); + const ingressPort = k8sProvider.config.ingressHttpPort; + return `http://${hostname}:${ingressPort}`; +} +function getInternalServiceUrl(ctx, service) { + return __awaiter(this, void 0, void 0, function* () { + return url_1.resolve(yield getInternalGatewayUrl(ctx), getServicePath(service)); + }); +} +function getOpenfaasNamespace(ctx, k8sProvider, skipCreate) { + return __awaiter(this, void 0, void 0, function* () { + return namespace_1.getNamespace({ ctx, provider: k8sProvider, skipCreate, suffix: "openfaas" }); + }); +} +function getOpenFaasGarden(ctx) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: figure out good way to retrieve namespace from kubernetes plugin through an exposed interface + // (maybe allow plugins to expose arbitrary data on the Provider object?) + const k8sProvider = getK8sProvider(ctx); + const namespace = yield getOpenfaasNamespace(ctx, k8sProvider, true); + const functionNamespace = yield namespace_1.getAppNamespace(ctx, k8sProvider); + const hostname = getExternalGatewayHostname(ctx.provider, k8sProvider); + // TODO: allow passing variables/parameters here to be parsed as part of the garden.yml project config + // (this would allow us to use a garden.yml for the project config, instead of speccing it here) + return garden_1.Garden.factory(systemProjectPath, { + env: "default", + config: { + version: "0", + dirname: "system", + path: systemProjectPath, + project: { + name: `${ctx.projectName}-openfaas`, + environmentDefaults: { + providers: [], + variables: {}, + }, + defaultEnvironment: "default", + environments: [ + { + name: "default", + providers: [ + Object.assign({}, k8sProvider.config, { namespace, + // TODO: this is clumsy, we should find a better way to configure this + _system: system_1.systemSymbol }), + ], + variables: { + "function-namespace": functionNamespace, + "gateway-hostname": hostname, + }, + }, + ], + }, + }, + }); + }); +} +exports.getOpenFaasGarden = getOpenFaasGarden; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["plugins/openfaas/openfaas.ts"],"names":[],"mappings":"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","file":"plugins/openfaas/openfaas.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Joi from \"joi\"\nimport { join } from \"path\"\nimport { resolve as urlResolve } from \"url\"\nimport { STATIC_DIR } from \"../../constants\"\nimport { PluginError, ConfigurationError } from \"../../exceptions\"\nimport { Garden } from \"../../garden\"\nimport { PluginContext } from \"../../plugin-context\"\nimport { joiArray, validate, PrimitiveMap } from \"../../config/common\"\nimport { Module } from \"../../types/module\"\nimport { ValidateModuleResult } from \"../../types/plugin/outputs\"\nimport {\n  PrepareEnvironmentParams,\n  GetEnvironmentStatusParams,\n  ValidateModuleParams,\n  DeleteServiceParams,\n} from \"../../types/plugin/params\"\nimport {\n  ServiceStatus,\n  ServiceIngress,\n  Service,\n} from \"../../types/service\"\nimport {\n  buildGenericModule,\n  GenericModuleSpec,\n  genericModuleSpecSchema,\n  GenericTestSpec,\n  testGenericModule,\n  getGenericModuleBuildStatus,\n} from \"../generic\"\nimport { KubernetesProvider } from \"../kubernetes/kubernetes\"\nimport { getNamespace, getAppNamespace } from \"../kubernetes/namespace\"\nimport {\n  DeployServiceParams,\n  GetServiceStatusParams,\n  BuildModuleParams,\n  GetServiceOutputsParams,\n} from \"../../types/plugin/params\"\nimport { every, values } from \"lodash\"\nimport { dumpYaml, findByName } from \"../../util/util\"\nimport * as execa from \"execa\"\nimport { KubeApi } from \"../kubernetes/api\"\nimport { waitForObjects, checkDeploymentStatus } from \"../kubernetes/status\"\nimport { systemSymbol } from \"../kubernetes/system\"\nimport { BaseServiceSpec } from \"../../config/service\"\nimport { GardenPlugin } from \"../../types/plugin/plugin\"\nimport { Provider, providerConfigBaseSchema } from \"../../config/project\"\nimport dedent = require(\"dedent\")\n\nconst systemProjectPath = join(STATIC_DIR, \"openfaas\", \"system\")\nexport const stackFilename = \"stack.yml\"\nexport const FAAS_CLI_IMAGE_ID = \"openfaas/faas-cli:0.7.3\"\n\nexport interface OpenFaasModuleSpec extends GenericModuleSpec {\n  handler: string\n  image: string\n  lang: string\n}\n\nexport const openfaasModuleSpecSchame = genericModuleSpecSchema\n  .keys({\n    dependencies: joiArray(Joi.string())\n      .description(\"The names of services/functions that this function depends on at runtime.\"),\n    handler: Joi.string()\n      .default(\".\")\n      .uri((<any>{ relativeOnly: true }))\n      .description(\"Specify which directory under the module contains the handler file/function.\"),\n    image: Joi.string()\n      .description(\"The image name to use for the built OpenFaaS container (defaults to the module name)\"),\n    lang: Joi.string()\n      .required()\n      .description(\"The OpenFaaS language template to use to build this function.\"),\n  })\n  .unknown(false)\n  .description(\"The module specification for an OpenFaaS module.\")\n\nexport interface OpenFaasModule extends Module<OpenFaasModuleSpec, BaseServiceSpec, GenericTestSpec> { }\nexport interface OpenFaasService extends Service<OpenFaasModule> { }\n\nexport interface OpenFaasConfig extends Provider {\n  hostname: string\n}\n\nconst configSchema = providerConfigBaseSchema\n  .keys({\n    hostname: Joi.string()\n      .hostname()\n      .description(dedent`\n        The hostname to configure for the function gateway.\n        Defaults to the default hostname of the configured Kubernetes provider.\n\n        Important: If you have other types of services, this should be different from their ingress hostnames,\n        or the other services should not expose paths under /function and /system to avoid routing conflicts.`,\n      )\n      .example(\"functions.mydomain.com\"),\n  })\n\ntype OpenFaasProvider = Provider<OpenFaasConfig>\n\nexport function gardenPlugin({ config }: { config: OpenFaasConfig }): GardenPlugin {\n  config = validate(config, configSchema, { context: \"OpenFaaS provider config\" })\n\n  return {\n    modules: [join(STATIC_DIR, \"openfaas\", \"builder\")],\n    actions: {\n      async getEnvironmentStatus({ ctx }: GetEnvironmentStatusParams) {\n        const ofGarden = await getOpenFaasGarden(ctx)\n        const status = await ofGarden.actions.getStatus()\n        const envReady = every(values(status.providers).map(s => s.ready))\n        const servicesReady = every(values(status.services).map(s => s.state === \"ready\"))\n\n        return {\n          ready: envReady && servicesReady,\n          detail: status,\n        }\n      },\n\n      async prepareEnvironment({ ctx, force }: PrepareEnvironmentParams) {\n        // TODO: refactor to dedupe similar code in local-kubernetes\n        const ofGarden = await getOpenFaasGarden(ctx)\n\n        await ofGarden.actions.prepareEnvironment({ force })\n\n        const results = await ofGarden.actions.deployServices({})\n        const failed = values(results.taskResults).filter(r => !!r.error).length\n\n        if (failed) {\n          throw new PluginError(`openfaas: ${failed} errors occurred when configuring environment`, {\n            results,\n          })\n        }\n\n        return {}\n      },\n\n      async cleanupEnvironment({ ctx }) {\n        const ofGarden = await getOpenFaasGarden(ctx)\n\n        return ofGarden.actions.cleanupEnvironment({})\n      },\n    },\n    moduleActions: {\n      openfaas: {\n        async validate({ moduleConfig }: ValidateModuleParams<OpenFaasModule>): Promise<ValidateModuleResult> {\n          moduleConfig.spec = validate(\n            moduleConfig.spec,\n            openfaasModuleSpecSchame,\n            { context: `module ${moduleConfig.name}` },\n          )\n\n          moduleConfig.build.command = [\n            \"faas-cli\",\n            \"build\",\n            \"-f\", stackFilename,\n          ]\n\n          moduleConfig.build.dependencies.push({\n            name: \"builder\",\n            plugin: \"openfaas\",\n            copy: [{\n              source: \"*\",\n              target: \".\",\n            }],\n          })\n\n          moduleConfig.serviceConfigs = [{\n            dependencies: [],\n            name: moduleConfig.name,\n            outputs: {},\n            spec: {\n              name: moduleConfig.name,\n              dependencies: [],\n              outputs: {},\n            },\n          }]\n\n          moduleConfig.testConfigs = moduleConfig.spec.tests.map(t => ({\n            name: t.name,\n            dependencies: t.dependencies,\n            spec: t,\n            timeout: t.timeout,\n          }))\n\n          return moduleConfig\n        },\n\n        getBuildStatus: getGenericModuleBuildStatus,\n\n        async build(params: BuildModuleParams<OpenFaasModule>) {\n          const { ctx, module } = params\n\n          // prepare the stack.yml file, before handing off the build to the generic handler\n          await writeStackFile(ctx, module, {})\n\n          return buildGenericModule(params)\n        },\n\n        // TODO: design and implement a proper test flow for openfaas functions\n        testModule: testGenericModule,\n\n        getServiceStatus,\n\n        async getServiceOutputs({ ctx, service }: GetServiceOutputsParams<OpenFaasModule>) {\n          return {\n            endpoint: await getInternalServiceUrl(ctx, service),\n          }\n        },\n\n        async deployService(params: DeployServiceParams<OpenFaasModule>): Promise<ServiceStatus> {\n          const { ctx, module, service, logEntry, runtimeContext } = params\n\n          // write the stack file again with environment variables\n          await writeStackFile(ctx, module, runtimeContext.envVars)\n\n          // use faas-cli to do the deployment\n          await execa(\"faas-cli\", [\"deploy\", \"-f\", stackFilename], { cwd: module.buildPath })\n\n          // wait until deployment is ready\n          const k8sProvider = getK8sProvider(ctx)\n          const namespace = await getAppNamespace(ctx, k8sProvider)\n          const api = new KubeApi(k8sProvider)\n\n          const deployment = (await api.apps.readNamespacedDeployment(service.name, namespace)).body\n\n          await waitForObjects({ ctx, provider: k8sProvider, service, logEntry, objects: [deployment] })\n\n          // TODO: avoid duplicate work here\n          return getServiceStatus(params)\n        },\n\n        async deleteService(params: DeleteServiceParams<OpenFaasModule>): Promise<ServiceStatus> {\n          const { ctx, logEntry, service, runtimeContext } = params\n          let status\n          let found = true\n\n          try {\n            status = await getServiceStatus({\n              ctx,\n              service,\n              runtimeContext,\n              module: service.module,\n            })\n\n            found = !!status.state\n\n            await execa(\"faas-cli\", [\"remove\", \"-f\", stackFilename], { cwd: service.module.buildPath })\n\n          } catch (err) {\n            found = false\n          }\n\n          if (logEntry) {\n            found ? logEntry.setSuccess(\"Service deleted\") : logEntry.setWarn(\"Service not deployed\")\n          }\n\n          return status\n        },\n      },\n    },\n  }\n}\n\nasync function writeStackFile(\n  ctx: PluginContext, module: OpenFaasModule, envVars: PrimitiveMap,\n) {\n  const image = getImageName(module)\n\n  const stackPath = join(module.buildPath, stackFilename)\n\n  return dumpYaml(stackPath, {\n    provider: {\n      name: \"faas\",\n      gateway: getExternalGatewayUrl(ctx),\n    },\n    functions: {\n      [module.name]: {\n        lang: module.spec.lang,\n        handler: module.spec.handler,\n        image,\n        environment: envVars,\n      },\n    },\n  })\n}\n\nasync function getServiceStatus({ ctx, service }: GetServiceStatusParams<OpenFaasModule>) {\n  const k8sProvider = getK8sProvider(ctx)\n\n  const ingresses: ServiceIngress[] = [{\n    hostname: getExternalGatewayHostname(ctx.provider, k8sProvider),\n    path: getServicePath(service),\n    port: k8sProvider.config.ingressHttpPort,\n    protocol: \"http\",\n  }]\n\n  const namespace = await getAppNamespace(ctx, k8sProvider)\n  const api = new KubeApi(k8sProvider)\n\n  let deployment\n\n  try {\n    deployment = (await api.apps.readNamespacedDeployment(service.name, namespace)).body\n  } catch (err) {\n    if (err.code === 404) {\n      return {}\n    } else {\n      throw err\n    }\n  }\n\n  const container: any = findByName(deployment.spec.template.spec.containers, \"hello-function\")\n  const version = findByName<any>(container.env, \"GARDEN_VERSION\").value\n  const status = await checkDeploymentStatus(api, namespace, deployment)\n\n  return {\n    state: status.state,\n    version,\n    ingresses,\n  }\n}\n\nfunction getImageName(module: OpenFaasModule) {\n  return `${module.name || module.spec.image}:${module.version.versionString}`\n}\n\n// NOTE: we're currently not using the CRD/operator, but might change that in the future\n//\n// async function createFunctionObject(service: OpenFaasService, namespace: string): Promise<KubernetesObject> {\n//   const image = await getImageName(service.module)\n\n//   return {\n//     apiVersion: \"openfaas.com/v1alpha2\",\n//     kind: \"Function\",\n//     metadata: {\n//       name: service.name,\n//       namespace,\n//     },\n//     spec: {\n//       name: service.name,\n//       image,\n//       labels: {\n//         \"com.openfaas.scale.min\": \"1\",\n//         \"com.openfaas.scale.max\": \"5\",\n//       },\n//       environment: {\n//         write_debug: \"true\",\n//       },\n//       limits: {\n//         cpu: DEFAULT_CPU_LIMIT,\n//         memory: DEFAULT_MEMORY_LIMIT,\n//       },\n//       requests: {\n//         cpu: DEFAULT_CPU_REQUEST,\n//         memory: DEFAULT_MEMORY_REQUEST,\n//       },\n//     },\n//   }\n// }\n\nfunction getK8sProvider(ctx: PluginContext): KubernetesProvider {\n  const provider = ctx.providers[\"local-kubernetes\"] || ctx.providers.kubernetes\n\n  if (!provider) {\n    throw new ConfigurationError(`openfaas requires a kubernetes (or local-kubernetes) provider to be configured`, {\n      configuredProviders: Object.keys(ctx.providers),\n    })\n  }\n\n  return provider\n}\n\nfunction getServicePath(service: OpenFaasService) {\n  return join(\"/\", \"function\", service.name)\n}\n\nasync function getInternalGatewayUrl(ctx: PluginContext) {\n  const k8sProvider = getK8sProvider(ctx)\n  const namespace = await getOpenfaasNamespace(ctx, k8sProvider, true)\n  return `http://gateway.${namespace}.svc.cluster.local:8080`\n}\n\nfunction getExternalGatewayHostname(provider: OpenFaasProvider, k8sProvider: KubernetesProvider) {\n  const hostname = provider.config.hostname || k8sProvider.config.defaultHostname\n\n  if (!hostname) {\n    throw new ConfigurationError(\n      `openfaas: Must configure hostname if no default hostname is configured on Kubernetes provider.`,\n      {\n        config: provider,\n      },\n    )\n  }\n\n  return hostname\n}\n\nfunction getExternalGatewayUrl(ctx: PluginContext) {\n  const k8sProvider = getK8sProvider(ctx)\n  const hostname = getExternalGatewayHostname(ctx.provider, k8sProvider)\n  const ingressPort = k8sProvider.config.ingressHttpPort\n  return `http://${hostname}:${ingressPort}`\n}\n\nasync function getInternalServiceUrl(ctx: PluginContext, service: OpenFaasService) {\n  return urlResolve(await getInternalGatewayUrl(ctx), getServicePath(service))\n}\n\nasync function getOpenfaasNamespace(ctx: PluginContext, k8sProvider: KubernetesProvider, skipCreate?: boolean) {\n  return getNamespace({ ctx, provider: k8sProvider, skipCreate, suffix: \"openfaas\" })\n}\n\nexport async function getOpenFaasGarden(ctx: PluginContext): Promise<Garden> {\n  // TODO: figure out good way to retrieve namespace from kubernetes plugin through an exposed interface\n  // (maybe allow plugins to expose arbitrary data on the Provider object?)\n  const k8sProvider = getK8sProvider(ctx)\n  const namespace = await getOpenfaasNamespace(ctx, k8sProvider, true)\n  const functionNamespace = await getAppNamespace(ctx, k8sProvider)\n\n  const hostname = getExternalGatewayHostname(ctx.provider, k8sProvider)\n\n  // TODO: allow passing variables/parameters here to be parsed as part of the garden.yml project config\n  // (this would allow us to use a garden.yml for the project config, instead of speccing it here)\n  return Garden.factory(systemProjectPath, {\n    env: \"default\",\n    config: {\n      version: \"0\",\n      dirname: \"system\",\n      path: systemProjectPath,\n      project: {\n        name: `${ctx.projectName}-openfaas`,\n        environmentDefaults: {\n          providers: [],\n          variables: {},\n        },\n        defaultEnvironment: \"default\",\n        environments: [\n          {\n            name: \"default\",\n            providers: [\n              {\n                ...k8sProvider.config,\n                namespace,\n                // TODO: this is clumsy, we should find a better way to configure this\n                _system: systemSymbol,\n              },\n            ],\n            variables: {\n              \"function-namespace\": functionNamespace,\n              \"gateway-hostname\": hostname,\n            },\n          },\n        ],\n      },\n    },\n  })\n}\n"]} diff --git a/garden-service/build/plugins/plugins.d.ts b/garden-service/build/plugins/plugins.d.ts new file mode 100644 index 00000000000..cee71b1c584 --- /dev/null +++ b/garden-service/build/plugins/plugins.d.ts @@ -0,0 +1,15 @@ +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +export declare const builtinPlugins: import("_").Dictionary; +export declare const fixedPlugins: string[]; +//# sourceMappingURL=plugins.d.ts.map \ No newline at end of file diff --git a/garden-service/build/plugins/plugins.js b/garden-service/build/plugins/plugins.js new file mode 100644 index 00000000000..13c49132c4d --- /dev/null +++ b/garden-service/build/plugins/plugins.js @@ -0,0 +1,38 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +const lodash_1 = require("lodash"); +const generic = require("./generic"); +const container = require("./container"); +const gcf = require("./google/google-cloud-functions"); +const localGcf = require("./local/local-google-cloud-functions"); +const kubernetes = require("./kubernetes/kubernetes"); +const localKubernetes = require("./kubernetes/local"); +const npmPackage = require("./npm-package"); +const gae = require("./google/google-app-engine"); +const openfaas = require("./openfaas/openfaas"); +// These plugins are always registered +exports.builtinPlugins = lodash_1.mapValues({ + generic, + container, + "google-cloud-functions": gcf, + "local-google-cloud-functions": localGcf, + kubernetes, + "local-kubernetes": localKubernetes, + "npm-package": npmPackage, + "google-app-engine": gae, + openfaas, +}, (m => m.gardenPlugin)); +// These plugins are always loaded +exports.fixedPlugins = [ + "generic", + "container", +]; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/process.d.ts b/garden-service/build/process.d.ts new file mode 100644 index 00000000000..fcdd8d1b3be --- /dev/null +++ b/garden-service/build/process.d.ts @@ -0,0 +1,26 @@ +import { Module } from "./types/module"; +import { Service } from "./types/service"; +import { Task } from "./tasks/base"; +import { TaskResults } from "./task-graph"; +import { Garden } from "./garden"; +export declare type ProcessHandler = (module: Module) => Promise; +interface ProcessParams { + garden: Garden; + watch: boolean; + handler: ProcessHandler; + changeHandler?: ProcessHandler; +} +export interface ProcessModulesParams extends ProcessParams { + modules: Module[]; +} +export interface ProcessServicesParams extends ProcessParams { + services: Service[]; +} +export interface ProcessResults { + taskResults: TaskResults; + restartRequired?: boolean; +} +export declare function processServices({ garden, services, watch, handler, changeHandler }: ProcessServicesParams): Promise; +export declare function processModules({ garden, modules, watch, handler, changeHandler }: ProcessModulesParams): Promise; +export {}; +//# sourceMappingURL=process.d.ts.map \ No newline at end of file diff --git a/garden-service/build/process.js b/garden-service/build/process.js new file mode 100644 index 00000000000..3581b0ff0f0 --- /dev/null +++ b/garden-service/build/process.js @@ -0,0 +1,83 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const chalk_1 = require("chalk"); +const watch_1 = require("./watch"); +const util_1 = require("./util/util"); +const ext_source_util_1 = require("./util/ext-source-util"); +function processServices({ garden, services, watch, handler, changeHandler }) { + return __awaiter(this, void 0, void 0, function* () { + const modules = Array.from(new Set(services.map(s => s.module))); + return processModules({ + modules, + garden, + watch, + handler, + changeHandler, + }); + }); +} +exports.processServices = processServices; +function processModules({ garden, modules, watch, handler, changeHandler }) { + return __awaiter(this, void 0, void 0, function* () { + for (const module of modules) { + const tasks = yield handler(module); + if (ext_source_util_1.isModuleLinked(module, garden)) { + garden.log.info(chalk_1.default.gray(`Reading module ${chalk_1.default.cyan(module.name)} from linked local path ${chalk_1.default.white(module.path)}`)); + } + yield Bluebird.map(tasks, t => garden.addTask(t)); + } + const results = yield garden.processTasks(); + if (!watch) { + return { + taskResults: results, + restartRequired: false, + }; + } + if (!changeHandler) { + changeHandler = handler; + } + const watcher = new watch_1.FSWatcher(garden); + const restartPromise = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + yield watcher.watchModules(modules, (changedModule, configChanged) => __awaiter(this, void 0, void 0, function* () { + if (configChanged) { + garden.log.debug({ msg: `Config changed, reloading.` }); + resolve(); + return; + } + if (changedModule) { + garden.log.debug({ msg: `Files changed for module ${changedModule.name}` }); + yield Bluebird.map(changeHandler(changedModule), (task) => garden.addTask(task)); + } + yield garden.processTasks(); + })); + util_1.registerCleanupFunction("clearAutoReloadWatches", () => { + watcher.close(); + }); + })); + yield restartPromise; + watcher.close(); + return { + taskResults: {}, + restartRequired: true, + }; + }); +} +exports.processModules = processModules; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/task-graph.d.ts b/garden-service/build/task-graph.d.ts new file mode 100644 index 00000000000..b0e123280c5 --- /dev/null +++ b/garden-service/build/task-graph.d.ts @@ -0,0 +1,41 @@ +import { Task } from "./tasks/base"; +import { Garden } from "./garden"; +export interface TaskResult { + type: string; + description: string; + output?: any; + dependencyResults?: TaskResults; + error?: Error; +} +export interface TaskResults { + [baseKey: string]: TaskResult; +} +export declare const DEFAULT_CONCURRENCY = 4; +export declare class TaskGraph { + private garden; + private concurrency; + private roots; + private index; + private inProgress; + private logEntryMap; + private resultCache; + private opQueue; + constructor(garden: Garden, concurrency?: number); + addTask(task: Task): Promise; + processTasks(): Promise; + private addTaskInternal; + private getNode; + private processTasksInternal; + private completeTask; + private getPredecessor; + private addDependencies; + private addDependants; + private inherit; + private remove; + private cancelDependants; + private logTask; + private logTaskComplete; + private initLogging; + private logTaskError; +} +//# sourceMappingURL=task-graph.d.ts.map \ No newline at end of file diff --git a/garden-service/build/task-graph.js b/garden-service/build/task-graph.js new file mode 100644 index 00000000000..b5bd0e5c840 --- /dev/null +++ b/garden-service/build/task-graph.js @@ -0,0 +1,378 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const PQueue = require("p-queue"); +const chalk_1 = require("chalk"); +const lodash_1 = require("lodash"); +const base_1 = require("./tasks/base"); +const exceptions_1 = require("./exceptions"); +class TaskGraphError extends Error { +} +exports.DEFAULT_CONCURRENCY = 4; +class TaskGraph { + constructor(garden, concurrency = exports.DEFAULT_CONCURRENCY) { + this.garden = garden; + this.concurrency = concurrency; + this.roots = new TaskNodeMap(); + this.index = new TaskNodeMap(); + this.inProgress = new TaskNodeMap(); + this.resultCache = new ResultCache(); + this.opQueue = new PQueue({ concurrency: 1 }); + this.logEntryMap = {}; + } + addTask(task) { + return __awaiter(this, void 0, void 0, function* () { + return this.opQueue.add(() => this.addTaskInternal(task)); + }); + } + processTasks() { + return __awaiter(this, void 0, void 0, function* () { + return this.opQueue.add(() => this.processTasksInternal()); + }); + } + addTaskInternal(task) { + return __awaiter(this, void 0, void 0, function* () { + const predecessor = this.getPredecessor(task); + let node = this.getNode(task); + if (predecessor) { + /* + predecessor is already in the graph, having the same baseKey as task, + but a different key (see the getPredecessor method below). + */ + if (this.inProgress.contains(predecessor)) { + this.index.addNode(node); + /* + We transition + [dependencies] > predecessor > [dependants] + to + [dependencies] > predecessor > node > [dependants] + */ + this.inherit(predecessor, node); + return; + } + else { + node = predecessor; // No need to add a new TaskNode. + } + } + this.index.addNode(node); + yield this.addDependencies(node); + if (node.getDependencies().length === 0) { + this.roots.addNode(node); + } + else { + yield this.addDependants(node); + } + }); + } + getNode(task) { + const existing = this.index.getNode(task); + return existing || new TaskNode(task); + } + /* + Process the graph until it's complete + */ + processTasksInternal() { + return __awaiter(this, void 0, void 0, function* () { + const _this = this; + const results = {}; + const loop = () => __awaiter(this, void 0, void 0, function* () { + if (_this.index.length === 0) { + // done! + this.logEntryMap.counter && this.logEntryMap.counter.setDone({ symbol: "info" }); + return; + } + const batch = _this.roots.getNodes() + .filter(n => !this.inProgress.contains(n)) + .slice(0, _this.concurrency - this.inProgress.length); + batch.forEach(n => this.inProgress.addNode(n)); + this.initLogging(); + return Bluebird.map(batch, (node) => __awaiter(this, void 0, void 0, function* () { + const task = node.task; + const type = node.getType(); + const baseKey = node.getBaseKey(); + const description = node.getDescription(); + let result; + try { + this.logTask(node); + this.logEntryMap.inProgress.setState(inProgressToStr(this.inProgress.getNodes())); + const dependencyBaseKeys = (yield task.getDependencies()) + .map(dep => dep.getBaseKey()); + const dependencyResults = lodash_1.merge(this.resultCache.pick(dependencyBaseKeys), lodash_1.pick(results, dependencyBaseKeys)); + try { + result = yield node.process(dependencyResults); + } + catch (error) { + result = { type, description, error }; + this.logTaskError(node, error); + this.cancelDependants(node); + } + finally { + results[baseKey] = result; + this.resultCache.put(baseKey, task.version.versionString, result); + } + } + finally { + this.completeTask(node, !result.error); + } + return loop(); + })); + }); + yield loop(); + return results; + }); + } + completeTask(node, success) { + if (node.getDependencies().length > 0) { + throw new TaskGraphError(`Task ${node.getKey()} still has unprocessed dependencies`); + } + for (let d of node.getDependants()) { + d.removeDependency(node); + if (d.getDependencies().length === 0) { + this.roots.addNode(d); + } + } + this.remove(node); + this.logTaskComplete(node, success); + } + getPredecessor(task) { + const key = task.getKey(); + const baseKey = task.getBaseKey(); + const predecessors = this.index.getNodes() + .filter(n => n.getBaseKey() === baseKey && n.getKey() !== key) + .reverse(); + return predecessors[0] || null; + } + addDependencies(node) { + return __awaiter(this, void 0, void 0, function* () { + const task = node.task; + for (const d of yield task.getDependencies()) { + if (!d.force && this.resultCache.get(d.getBaseKey(), d.version.versionString)) { + continue; + } + const dependency = this.getPredecessor(d) || this.getNode(d); + this.index.addNode(dependency); + node.addDependency(dependency); + } + }); + } + addDependants(node) { + return __awaiter(this, void 0, void 0, function* () { + const nodeDependencies = node.getDependencies(); + for (const d of nodeDependencies) { + const dependant = this.getPredecessor(d.task) || d; + yield this.addTaskInternal(dependant.task); + dependant.addDependant(node); + } + }); + } + inherit(oldNode, newNode) { + oldNode.getDependants().forEach(node => { + newNode.addDependant(node); + oldNode.removeDependant(node); + node.removeDependency(oldNode); + node.addDependency(newNode); + }); + newNode.addDependency(oldNode); + oldNode.addDependant(newNode); + } + // Should only be called when node is not a dependant for any task. + remove(node) { + this.roots.removeNode(node); + this.index.removeNode(node); + this.inProgress.removeNode(node); + } + // Recursively remove node's dependants, without removing node. + cancelDependants(node) { + const remover = (n) => { + for (const dependant of n.getDependants()) { + this.logTaskComplete(n, false); + remover(dependant); + } + this.remove(n); + }; + for (const dependant of node.getDependants()) { + node.removeDependant(dependant); + remover(dependant); + } + } + // Logging + logTask(node) { + const entry = this.garden.log.debug({ + section: "tasks", + msg: `Processing task ${taskStyle(node.getKey())}`, + status: "active", + }); + this.logEntryMap[node.getKey()] = entry; + } + logTaskComplete(node, success) { + const entry = this.logEntryMap[node.getKey()]; + if (entry) { + success ? entry.setSuccess() : entry.setError(); + } + this.logEntryMap.counter.setState(remainingTasksToStr(this.index.length)); + } + initLogging() { + if (!Object.keys(this.logEntryMap).length) { + const header = this.garden.log.debug("Processing tasks..."); + const counter = this.garden.log.debug({ + msg: remainingTasksToStr(this.index.length), + status: "active", + }); + const inProgress = this.garden.log.debug(inProgressToStr(this.inProgress.getNodes())); + this.logEntryMap = Object.assign({}, this.logEntryMap, { header, + counter, + inProgress }); + } + } + logTaskError(node, err) { + const divider = lodash_1.padEnd("", 80, "—"); + const error = exceptions_1.toGardenError(err); + const msg = `\nFailed ${node.getDescription()}. Here is the output:\n${divider}\n${error.message}\n${divider}\n`; + this.garden.log.error({ msg, error }); + } +} +exports.TaskGraph = TaskGraph; +function getIndexKey(task) { + const key = task.getKey(); + if (!task.type || !key || task.type.length === 0 || key.length === 0) { + throw new base_1.TaskDefinitionError("Tasks must define a type and a key"); + } + return key; +} +class TaskNodeMap { + constructor() { + this.index = new Map(); + this.length = 0; + } + getNode(task) { + const indexKey = getIndexKey(task); + const element = this.index.get(indexKey); + return element; + } + addNode(node) { + const indexKey = node.getKey(); + if (!this.index.get(indexKey)) { + this.index.set(indexKey, node); + this.length++; + } + } + removeNode(node) { + if (this.index.delete(node.getKey())) { + this.length--; + } + } + getNodes() { + return Array.from(this.index.values()); + } + contains(node) { + return this.index.has(node.getKey()); + } +} +class TaskNode { + constructor(task) { + this.task = task; + this.dependencies = new TaskNodeMap(); + this.dependants = new TaskNodeMap(); + } + addDependency(node) { + this.dependencies.addNode(node); + } + addDependant(node) { + this.dependants.addNode(node); + } + removeDependency(node) { + this.dependencies.removeNode(node); + } + removeDependant(node) { + this.dependants.removeNode(node); + } + getDependencies() { + return this.dependencies.getNodes(); + } + getDependants() { + return this.dependants.getNodes(); + } + getBaseKey() { + return this.task.getBaseKey(); + } + getKey() { + return getIndexKey(this.task); + } + getDescription() { + return this.task.getDescription(); + } + getType() { + return this.task.type; + } + // For testing/debugging purposes + inspect() { + return { + key: this.getKey(), + dependencies: this.getDependencies().map(d => d.getKey()), + dependants: this.getDependants().map(d => d.getKey()), + }; + } + process(dependencyResults) { + return __awaiter(this, void 0, void 0, function* () { + const output = yield this.task.process(dependencyResults); + return { + type: this.getType(), + description: this.getDescription(), + output, + dependencyResults, + }; + }); + } +} +class ResultCache { + constructor() { + this.cache = {}; + } + put(baseKey, versionString, result) { + this.cache[baseKey] = { result, versionString }; + } + get(baseKey, versionString) { + const r = this.cache[baseKey]; + return (r && r.versionString === versionString && !r.result.error) ? r.result : null; + } + getNewest(baseKey) { + const r = this.cache[baseKey]; + return (r && !r.result.error) ? r.result : null; + } + // Returns newest cached results, if any, for baseKeys + pick(baseKeys) { + const results = {}; + for (const baseKey of baseKeys) { + const cachedResult = this.getNewest(baseKey); + if (cachedResult) { + results[baseKey] = cachedResult; + } + } + return results; + } +} +const taskStyle = chalk_1.default.cyan.bold; +function inProgressToStr(nodes) { + return `Currently in progress [${nodes.map(n => taskStyle(n.getKey())).join(", ")}]`; +} +function remainingTasksToStr(num) { + const style = num === 0 ? chalk_1.default.green : chalk_1.default.yellow; + return `Remaining tasks ${style.bold(String(num))}`; +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["task-graph.ts"],"names":[],"mappings":"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","file":"task-graph.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Bluebird from \"bluebird\"\nimport * as PQueue from \"p-queue\"\nimport chalk from \"chalk\"\nimport { merge, padEnd, pick } from \"lodash\"\nimport { Task, TaskDefinitionError } from \"./tasks/base\"\n\nimport { LogEntry } from \"./logger/log-entry\"\nimport { toGardenError } from \"./exceptions\"\nimport { Garden } from \"./garden\"\n\nclass TaskGraphError extends Error { }\n\nexport interface TaskResult {\n  type: string\n  description: string\n  output?: any\n  dependencyResults?: TaskResults\n  error?: Error\n}\n\n/*\n  When multiple tasks with the same baseKey are completed during a call to processTasks,\n  the result from the last processed is used (hence only one key-value pair here per baseKey).\n */\nexport interface TaskResults {\n  [baseKey: string]: TaskResult\n}\n\nexport const DEFAULT_CONCURRENCY = 4\n\nexport class TaskGraph {\n  private roots: TaskNodeMap\n  private index: TaskNodeMap\n\n  private inProgress: TaskNodeMap\n  private logEntryMap: LogEntryMap\n\n  private resultCache: ResultCache\n  private opQueue: PQueue\n\n  constructor(private garden: Garden, private concurrency: number = DEFAULT_CONCURRENCY) {\n    this.roots = new TaskNodeMap()\n    this.index = new TaskNodeMap()\n    this.inProgress = new TaskNodeMap()\n    this.resultCache = new ResultCache()\n    this.opQueue = new PQueue({ concurrency: 1 })\n    this.logEntryMap = {}\n  }\n\n  async addTask(task: Task): Promise<void> {\n    return this.opQueue.add(() => this.addTaskInternal(task))\n  }\n\n  async processTasks(): Promise<TaskResults> {\n    return this.opQueue.add(() => this.processTasksInternal())\n  }\n\n  private async addTaskInternal(task: Task) {\n    const predecessor = this.getPredecessor(task)\n    let node = this.getNode(task)\n\n    if (predecessor) {\n      /*\n        predecessor is already in the graph, having the same baseKey as task,\n        but a different key (see the getPredecessor method below).\n      */\n      if (this.inProgress.contains(predecessor)) {\n        this.index.addNode(node)\n        /*\n          We transition\n            [dependencies] > predecessor > [dependants]\n          to\n            [dependencies] > predecessor > node > [dependants]\n         */\n        this.inherit(predecessor, node)\n        return\n      } else {\n        node = predecessor // No need to add a new TaskNode.\n      }\n    }\n\n    this.index.addNode(node)\n    await this.addDependencies(node)\n\n    if (node.getDependencies().length === 0) {\n      this.roots.addNode(node)\n    } else {\n      await this.addDependants(node)\n    }\n  }\n\n  private getNode(task: Task): TaskNode {\n    const existing = this.index.getNode(task)\n    return existing || new TaskNode(task)\n  }\n  /*\n    Process the graph until it's complete\n   */\n  private async processTasksInternal(): Promise<TaskResults> {\n    const _this = this\n    const results: TaskResults = {}\n\n    const loop = async () => {\n      if (_this.index.length === 0) {\n        // done!\n        this.logEntryMap.counter && this.logEntryMap.counter.setDone({ symbol: \"info\" })\n        return\n      }\n\n      const batch = _this.roots.getNodes()\n        .filter(n => !this.inProgress.contains(n))\n        .slice(0, _this.concurrency - this.inProgress.length)\n\n      batch.forEach(n => this.inProgress.addNode(n))\n\n      this.initLogging()\n\n      return Bluebird.map(batch, async (node: TaskNode) => {\n        const task = node.task\n        const type = node.getType()\n        const baseKey = node.getBaseKey()\n        const description = node.getDescription()\n        let result\n\n        try {\n          this.logTask(node)\n          this.logEntryMap.inProgress.setState(inProgressToStr(this.inProgress.getNodes()))\n\n          const dependencyBaseKeys = (await task.getDependencies())\n            .map(dep => dep.getBaseKey())\n\n          const dependencyResults = merge(\n            this.resultCache.pick(dependencyBaseKeys),\n            pick(results, dependencyBaseKeys))\n\n          try {\n            result = await node.process(dependencyResults)\n          } catch (error) {\n            result = { type, description, error }\n            this.logTaskError(node, error)\n            this.cancelDependants(node)\n          } finally {\n            results[baseKey] = result\n            this.resultCache.put(baseKey, task.version.versionString, result)\n          }\n        } finally {\n          this.completeTask(node, !result.error)\n        }\n\n        return loop()\n      })\n    }\n\n    await loop()\n\n    return results\n  }\n\n  private completeTask(node: TaskNode, success: boolean) {\n    if (node.getDependencies().length > 0) {\n      throw new TaskGraphError(`Task ${node.getKey()} still has unprocessed dependencies`)\n    }\n\n    for (let d of node.getDependants()) {\n      d.removeDependency(node)\n\n      if (d.getDependencies().length === 0) {\n        this.roots.addNode(d)\n      }\n    }\n\n    this.remove(node)\n    this.logTaskComplete(node, success)\n  }\n\n  private getPredecessor(task: Task): TaskNode | null {\n    const key = task.getKey()\n    const baseKey = task.getBaseKey()\n    const predecessors = this.index.getNodes()\n      .filter(n => n.getBaseKey() === baseKey && n.getKey() !== key)\n      .reverse()\n    return predecessors[0] || null\n  }\n\n  private async addDependencies(node: TaskNode) {\n    const task = node.task\n    for (const d of await task.getDependencies()) {\n\n      if (!d.force && this.resultCache.get(d.getBaseKey(), d.version.versionString)) {\n        continue\n      }\n\n      const dependency = this.getPredecessor(d) || this.getNode(d)\n      this.index.addNode(dependency)\n      node.addDependency(dependency)\n\n    }\n  }\n\n  private async addDependants(node: TaskNode) {\n    const nodeDependencies = node.getDependencies()\n    for (const d of nodeDependencies) {\n      const dependant = this.getPredecessor(d.task) || d\n      await this.addTaskInternal(dependant.task)\n      dependant.addDependant(node)\n    }\n  }\n\n  private inherit(oldNode: TaskNode, newNode: TaskNode) {\n    oldNode.getDependants().forEach(node => {\n      newNode.addDependant(node)\n      oldNode.removeDependant(node)\n      node.removeDependency(oldNode)\n      node.addDependency(newNode)\n    })\n\n    newNode.addDependency(oldNode)\n    oldNode.addDependant(newNode)\n  }\n\n  // Should only be called when node is not a dependant for any task.\n  private remove(node: TaskNode) {\n    this.roots.removeNode(node)\n    this.index.removeNode(node)\n    this.inProgress.removeNode(node)\n  }\n\n  // Recursively remove node's dependants, without removing node.\n  private cancelDependants(node: TaskNode) {\n    const remover = (n) => {\n      for (const dependant of n.getDependants()) {\n        this.logTaskComplete(n, false)\n        remover(dependant)\n      }\n      this.remove(n)\n    }\n\n    for (const dependant of node.getDependants()) {\n      node.removeDependant(dependant)\n      remover(dependant)\n    }\n  }\n\n  // Logging\n  private logTask(node: TaskNode) {\n    const entry = this.garden.log.debug({\n      section: \"tasks\",\n      msg: `Processing task ${taskStyle(node.getKey())}`,\n      status: \"active\",\n    })\n    this.logEntryMap[node.getKey()] = entry\n  }\n\n  private logTaskComplete(node: TaskNode, success: boolean) {\n    const entry = this.logEntryMap[node.getKey()]\n    if (entry) {\n      success ? entry.setSuccess() : entry.setError()\n    }\n    this.logEntryMap.counter.setState(remainingTasksToStr(this.index.length))\n  }\n\n  private initLogging() {\n    if (!Object.keys(this.logEntryMap).length) {\n      const header = this.garden.log.debug(\"Processing tasks...\")\n      const counter = this.garden.log.debug({\n        msg: remainingTasksToStr(this.index.length),\n        status: \"active\",\n      })\n      const inProgress = this.garden.log.debug(inProgressToStr(this.inProgress.getNodes()))\n      this.logEntryMap = {\n        ...this.logEntryMap,\n        header,\n        counter,\n        inProgress,\n      }\n    }\n  }\n\n  private logTaskError(node: TaskNode, err) {\n    const divider = padEnd(\"\", 80, \"—\")\n    const error = toGardenError(err)\n    const msg = `\\nFailed ${node.getDescription()}. Here is the output:\\n${divider}\\n${error.message}\\n${divider}\\n`\n    this.garden.log.error({ msg, error })\n  }\n}\n\nfunction getIndexKey(task: Task) {\n  const key = task.getKey()\n\n  if (!task.type || !key || task.type.length === 0 || key.length === 0) {\n    throw new TaskDefinitionError(\"Tasks must define a type and a key\")\n  }\n\n  return key\n}\n\nclass TaskNodeMap {\n  // Map is used here to facilitate in-order traversal.\n  index: Map<string, TaskNode>\n  length: number\n\n  constructor() {\n    this.index = new Map()\n    this.length = 0\n  }\n\n  getNode(task: Task) {\n    const indexKey = getIndexKey(task)\n    const element = this.index.get(indexKey)\n    return element\n  }\n\n  addNode(node: TaskNode): void {\n    const indexKey = node.getKey()\n\n    if (!this.index.get(indexKey)) {\n      this.index.set(indexKey, node)\n      this.length++\n    }\n  }\n\n  removeNode(node: TaskNode): void {\n    if (this.index.delete(node.getKey())) {\n      this.length--\n    }\n  }\n\n  getNodes(): TaskNode[] {\n    return Array.from(this.index.values())\n  }\n\n  contains(node: TaskNode): boolean {\n    return this.index.has(node.getKey())\n  }\n\n}\n\nclass TaskNode {\n  task: Task\n\n  private dependencies: TaskNodeMap\n  private dependants: TaskNodeMap\n\n  constructor(task: Task) {\n    this.task = task\n    this.dependencies = new TaskNodeMap()\n    this.dependants = new TaskNodeMap()\n  }\n\n  addDependency(node: TaskNode) {\n    this.dependencies.addNode(node)\n  }\n\n  addDependant(node: TaskNode) {\n    this.dependants.addNode(node)\n  }\n\n  removeDependency(node: TaskNode) {\n    this.dependencies.removeNode(node)\n  }\n\n  removeDependant(node: TaskNode) {\n    this.dependants.removeNode(node)\n  }\n\n  getDependencies() {\n    return this.dependencies.getNodes()\n  }\n\n  getDependants() {\n    return this.dependants.getNodes()\n  }\n\n  getBaseKey() {\n    return this.task.getBaseKey()\n  }\n\n  getKey() {\n    return getIndexKey(this.task)\n  }\n\n  getDescription() {\n    return this.task.getDescription()\n  }\n\n  getType() {\n    return this.task.type\n  }\n\n  // For testing/debugging purposes\n  inspect(): object {\n    return {\n      key: this.getKey(),\n      dependencies: this.getDependencies().map(d => d.getKey()),\n      dependants: this.getDependants().map(d => d.getKey()),\n    }\n  }\n\n  async process(dependencyResults: TaskResults) {\n    const output = await this.task.process(dependencyResults)\n\n    return {\n      type: this.getType(),\n      description: this.getDescription(),\n      output,\n      dependencyResults,\n    }\n  }\n}\n\ninterface CachedResult {\n  result: TaskResult,\n  versionString: string\n}\n\nclass ResultCache {\n  /*\n    By design, at most one TaskResult (the most recently processed) is cached for a given baseKey.\n\n    Invariant: No concurrent calls are made to this class' instance methods, since they\n    only happen within TaskGraph's addTaskInternal and processTasksInternal methods,\n    which are never executed concurrently, since they are executed sequentially by the\n    operation queue.\n  */\n  private cache: { [key: string]: CachedResult }\n\n  constructor() {\n    this.cache = {}\n  }\n\n  put(baseKey: string, versionString: string, result: TaskResult): void {\n    this.cache[baseKey] = { result, versionString }\n  }\n\n  get(baseKey: string, versionString: string): TaskResult | null {\n    const r = this.cache[baseKey]\n    return (r && r.versionString === versionString && !r.result.error) ? r.result : null\n  }\n\n  getNewest(baseKey: string): TaskResult | null {\n    const r = this.cache[baseKey]\n    return (r && !r.result.error) ? r.result : null\n  }\n\n  // Returns newest cached results, if any, for baseKeys\n  pick(baseKeys: string[]): TaskResults {\n    const results: TaskResults = {}\n\n    for (const baseKey of baseKeys) {\n      const cachedResult = this.getNewest(baseKey)\n      if (cachedResult) {\n        results[baseKey] = cachedResult\n      }\n    }\n\n    return results\n  }\n\n}\n\ninterface LogEntryMap { [key: string]: LogEntry }\n\nconst taskStyle = chalk.cyan.bold\n\nfunction inProgressToStr(nodes) {\n  return `Currently in progress [${nodes.map(n => taskStyle(n.getKey())).join(\", \")}]`\n}\n\nfunction remainingTasksToStr(num) {\n  const style = num === 0 ? chalk.green : chalk.yellow\n  return `Remaining tasks ${style.bold(String(num))}`\n}\n"]} diff --git a/garden-service/build/tasks/base.d.ts b/garden-service/build/tasks/base.d.ts new file mode 100644 index 00000000000..03d0e35a001 --- /dev/null +++ b/garden-service/build/tasks/base.d.ts @@ -0,0 +1,26 @@ +import { TaskResults } from "../task-graph"; +import { ModuleVersion } from "../vcs/base"; +import { Garden } from "../garden"; +export declare class TaskDefinitionError extends Error { +} +export interface TaskParams { + garden: Garden; + force?: boolean; + version: ModuleVersion; +} +export declare abstract class Task { + abstract type: string; + garden: Garden; + id: string; + force: boolean; + version: ModuleVersion; + dependencies: Task[]; + constructor(initArgs: TaskParams); + getDependencies(): Promise; + protected abstract getName(): string; + getBaseKey(): string; + getKey(): string; + abstract getDescription(): string; + abstract process(dependencyResults: TaskResults): Promise; +} +//# sourceMappingURL=base.d.ts.map \ No newline at end of file diff --git a/garden-service/build/tasks/base.js b/garden-service/build/tasks/base.js new file mode 100644 index 00000000000..23417d3fc27 --- /dev/null +++ b/garden-service/build/tasks/base.js @@ -0,0 +1,44 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const uuid_1 = require("uuid"); +class TaskDefinitionError extends Error { +} +exports.TaskDefinitionError = TaskDefinitionError; +class Task { + constructor(initArgs) { + this.garden = initArgs.garden; + this.dependencies = []; + this.id = uuid_1.v1(); // uuidv1 is timestamp-based + this.force = !!initArgs.force; + this.version = initArgs.version; + } + getDependencies() { + return __awaiter(this, void 0, void 0, function* () { + return this.dependencies; + }); + } + getBaseKey() { + return `${this.type}.${this.getName()}`; + } + getKey() { + return `${this.getBaseKey()}.${this.id}`; + } +} +exports.Task = Task; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/tasks/build.d.ts b/garden-service/build/tasks/build.d.ts new file mode 100644 index 00000000000..31bcf3f099a --- /dev/null +++ b/garden-service/build/tasks/build.d.ts @@ -0,0 +1,19 @@ +import { Module } from "../types/module"; +import { BuildResult } from "../types/plugin/outputs"; +import { Task } from "../tasks/base"; +import { Garden } from "../garden"; +export interface BuildTaskParams { + garden: Garden; + module: Module; + force: boolean; +} +export declare class BuildTask extends Task { + type: string; + private module; + constructor({ garden, force, module }: BuildTaskParams); + getDependencies(): Promise; + protected getName(): string; + getDescription(): string; + process(): Promise; +} +//# sourceMappingURL=build.d.ts.map \ No newline at end of file diff --git a/garden-service/build/tasks/build.js b/garden-service/build/tasks/build.js new file mode 100644 index 00000000000..8b6bf24bd89 --- /dev/null +++ b/garden-service/build/tasks/build.js @@ -0,0 +1,76 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const chalk_1 = require("chalk"); +const base_1 = require("../tasks/base"); +class BuildTask extends base_1.Task { + constructor({ garden, force, module }) { + super({ garden, force, version: module.version }); + this.type = "build"; + this.module = module; + } + getDependencies() { + return __awaiter(this, void 0, void 0, function* () { + const deps = yield this.garden.resolveModuleDependencies(this.module.build.dependencies, []); + return Bluebird.map(deps, (m) => __awaiter(this, void 0, void 0, function* () { + return new BuildTask({ + garden: this.garden, + module: m, + force: this.force, + }); + })); + }); + } + getName() { + return this.module.name; + } + getDescription() { + return `building ${this.module.name}`; + } + process() { + return __awaiter(this, void 0, void 0, function* () { + const module = this.module; + if (!this.force && (yield this.garden.actions.getBuildStatus({ module })).ready) { + // this is necessary in case other modules depend on files from this one + yield this.garden.buildDir.syncDependencyProducts(this.module); + return { fresh: false }; + } + const logEntry = this.garden.log.info({ + section: this.module.name, + msg: "Building", + status: "active", + }); + let result; + try { + result = yield this.garden.actions.build({ + module, + logEntry, + }); + } + catch (err) { + logEntry.setError(); + throw err; + } + logEntry.setSuccess({ msg: chalk_1.default.green(`Done (took ${logEntry.getDuration(1)} sec)`), append: true }); + return result; + }); + } +} +exports.BuildTask = BuildTask; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/tasks/deploy.d.ts b/garden-service/build/tasks/deploy.d.ts new file mode 100644 index 00000000000..13dfd2fb9ce --- /dev/null +++ b/garden-service/build/tasks/deploy.d.ts @@ -0,0 +1,32 @@ +import { LogEntry } from "../logger/log-entry"; +import { Task } from "./base"; +import { Service, ServiceStatus } from "../types/service"; +import { Module } from "../types/module"; +import { Garden } from "../garden"; +export interface DeployTaskParams { + garden: Garden; + service: Service; + force: boolean; + forceBuild: boolean; + logEntry?: LogEntry; +} +export declare class DeployTask extends Task { + type: string; + private service; + private forceBuild; + private logEntry?; + constructor({ garden, service, force, forceBuild, logEntry }: DeployTaskParams); + getDependencies(): Promise; + protected getName(): string; + getDescription(): string; + process(): Promise; +} +export declare function getDeployTasks({ garden, module, serviceNames, force, forceBuild, includeDependants }: { + garden: Garden; + module: Module; + serviceNames?: string[] | null; + force?: boolean; + forceBuild?: boolean; + includeDependants?: boolean; +}): Promise; +//# sourceMappingURL=deploy.d.ts.map \ No newline at end of file diff --git a/garden-service/build/tasks/deploy.js b/garden-service/build/tasks/deploy.js new file mode 100644 index 00000000000..7ab1d285a21 --- /dev/null +++ b/garden-service/build/tasks/deploy.js @@ -0,0 +1,115 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const Bluebird = require("bluebird"); +const chalk_1 = require("chalk"); +const base_1 = require("./base"); +const service_1 = require("../types/service"); +const watch_1 = require("../watch"); +const util_1 = require("../util/util"); +const push_1 = require("./push"); +class DeployTask extends base_1.Task { + constructor({ garden, service, force, forceBuild, logEntry }) { + super({ garden, force, version: service.module.version }); + this.type = "deploy"; + this.service = service; + this.forceBuild = forceBuild; + this.logEntry = logEntry; + } + getDependencies() { + return __awaiter(this, void 0, void 0, function* () { + const serviceDeps = this.service.config.dependencies; + const services = yield this.garden.getServices(serviceDeps); + const deps = yield Bluebird.map(services, (service) => __awaiter(this, void 0, void 0, function* () { + return new DeployTask({ + garden: this.garden, + service, + force: false, + forceBuild: this.forceBuild, + }); + })); + deps.push(new push_1.PushTask({ + garden: this.garden, + module: this.service.module, + forceBuild: this.forceBuild, + })); + return deps; + }); + } + getName() { + return this.service.name; + } + getDescription() { + return `deploying service ${this.service.name} (from module ${this.service.module.name})`; + } + process() { + return __awaiter(this, void 0, void 0, function* () { + const logEntry = (this.logEntry || this.garden.log).info({ + section: this.service.name, + msg: "Checking status", + status: "active", + }); + // TODO: get version from build task results + const { versionString } = yield this.service.module.version; + const status = yield this.garden.actions.getServiceStatus({ service: this.service, logEntry }); + if (!this.force && + versionString === status.version && + status.state === "ready") { + // already deployed and ready + logEntry.setSuccess({ + msg: `Version ${versionString} already deployed`, + append: true, + }); + return status; + } + logEntry.setState("Deploying"); + const dependencies = yield this.garden.getServices(this.service.config.dependencies); + let result; + try { + result = yield this.garden.actions.deployService({ + service: this.service, + runtimeContext: yield service_1.prepareRuntimeContext(this.garden, this.service.module, dependencies), + logEntry, + force: this.force, + }); + } + catch (err) { + logEntry.setError(); + throw err; + } + logEntry.setSuccess({ msg: chalk_1.default.green(`Ready`), append: true }); + return result; + }); + } +} +exports.DeployTask = DeployTask; +function getDeployTasks({ garden, module, serviceNames, force = false, forceBuild = false, includeDependants = false }) { + return __awaiter(this, void 0, void 0, function* () { + const modulesToProcess = includeDependants + ? (yield watch_1.withDependants(garden, [module], yield watch_1.computeAutoReloadDependants(garden))) + : [module]; + const moduleServices = lodash_1.flatten(yield Bluebird.map(modulesToProcess, m => garden.getServices(util_1.getNames(m.serviceConfigs)))); + const servicesToProcess = serviceNames + ? moduleServices.filter(s => serviceNames.includes(s.name)) + : moduleServices; + return servicesToProcess.map(service => new DeployTask({ garden, service, force, forceBuild })); + }); +} +exports.getDeployTasks = getDeployTasks; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["tasks/deploy.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;;;;;AAEH,mCAAgC;AAChC,qCAAoC;AACpC,iCAAyB;AAEzB,iCAA6B;AAC7B,8CAIyB;AAEzB,oCAAsE;AACtE,uCAAuC;AAEvC,iCAAiC;AAUjC,MAAa,UAAW,SAAQ,WAAI;IAOlC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAoB;QAC5E,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAA;QAP3D,SAAI,GAAG,QAAQ,CAAA;QAQb,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;IAC1B,CAAC;IAEK,eAAe;;YACnB,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAA;YACpD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,CAAA;YAE3D,MAAM,IAAI,GAAW,MAAM,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAO,OAAO,EAAE,EAAE;gBAClE,OAAO,IAAI,UAAU,CAAC;oBACpB,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,OAAO;oBACP,KAAK,EAAE,KAAK;oBACZ,UAAU,EAAE,IAAI,CAAC,UAAU;iBAC5B,CAAC,CAAA;YACJ,CAAC,CAAA,CAAC,CAAA;YAEF,IAAI,CAAC,IAAI,CAAC,IAAI,eAAQ,CAAC;gBACrB,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM;gBAC3B,UAAU,EAAE,IAAI,CAAC,UAAU;aAC5B,CAAC,CAAC,CAAA;YAEH,OAAO,IAAI,CAAA;QACb,CAAC;KAAA;IAES,OAAO;QACf,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAA;IAC1B,CAAC;IAED,cAAc;QACZ,OAAO,qBAAqB,IAAI,CAAC,OAAO,CAAC,IAAI,iBAAiB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,GAAG,CAAA;IAC3F,CAAC;IAEK,OAAO;;YACX,MAAM,QAAQ,GAAG,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC;gBACvD,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;gBAC1B,GAAG,EAAE,iBAAiB;gBACtB,MAAM,EAAE,QAAQ;aACjB,CAAC,CAAA;YAEF,4CAA4C;YAC5C,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAA;YAC3D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAA;YAE9F,IACE,CAAC,IAAI,CAAC,KAAK;gBACX,aAAa,KAAK,MAAM,CAAC,OAAO;gBAChC,MAAM,CAAC,KAAK,KAAK,OAAO,EACxB;gBACA,6BAA6B;gBAC7B,QAAQ,CAAC,UAAU,CAAC;oBAClB,GAAG,EAAE,WAAW,aAAa,mBAAmB;oBAChD,MAAM,EAAE,IAAI;iBACb,CAAC,CAAA;gBACF,OAAO,MAAM,CAAA;aACd;YAED,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAA;YAE9B,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAA;YAEpF,IAAI,MAAqB,CAAA;YACzB,IAAI;gBACF,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC;oBAC/C,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,cAAc,EAAE,MAAM,+BAAqB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,YAAY,CAAC;oBAC3F,QAAQ;oBACR,KAAK,EAAE,IAAI,CAAC,KAAK;iBAClB,CAAC,CAAA;aACH;YAAC,OAAO,GAAG,EAAE;gBACZ,QAAQ,CAAC,QAAQ,EAAE,CAAA;gBACnB,MAAM,GAAG,CAAA;aACV;YAED,QAAQ,CAAC,UAAU,CAAC,EAAE,GAAG,EAAE,eAAK,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAA;YAChE,OAAO,MAAM,CAAA;QACf,CAAC;KAAA;CACF;AAxFD,gCAwFC;AAED,SAAsB,cAAc,CAClC,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,GAAG,KAAK,EAAE,UAAU,GAAG,KAAK,EAAE,iBAAiB,GAAG,KAAK,EAIzF;;QAGH,MAAM,gBAAgB,GAAG,iBAAiB;YACxC,CAAC,CAAC,CAAC,MAAM,sBAAc,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,mCAA2B,CAAC,MAAM,CAAC,CAAC,CAAC;YACrF,CAAC,CAAC,CAAC,MAAM,CAAC,CAAA;QAEZ,MAAM,cAAc,GAAG,gBAAO,CAAC,MAAM,QAAQ,CAAC,GAAG,CAC/C,gBAAgB,EAChB,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,eAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;QAEvD,MAAM,iBAAiB,GAAG,YAAY;YACpC,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAC3D,CAAC,CAAC,cAAc,CAAA;QAElB,OAAO,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC,CAAA;IACjG,CAAC;CAAA;AArBD,wCAqBC","file":"tasks/deploy.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { flatten } from \"lodash\"\nimport * as Bluebird from \"bluebird\"\nimport chalk from \"chalk\"\nimport { LogEntry } from \"../logger/log-entry\"\nimport { Task } from \"./base\"\nimport {\n  Service,\n  ServiceStatus,\n  prepareRuntimeContext,\n} from \"../types/service\"\nimport { Module } from \"../types/module\"\nimport { withDependants, computeAutoReloadDependants } from \"../watch\"\nimport { getNames } from \"../util/util\"\nimport { Garden } from \"../garden\"\nimport { PushTask } from \"./push\"\n\nexport interface DeployTaskParams {\n  garden: Garden\n  service: Service\n  force: boolean\n  forceBuild: boolean\n  logEntry?: LogEntry\n}\n\nexport class DeployTask extends Task {\n  type = \"deploy\"\n\n  private service: Service\n  private forceBuild: boolean\n  private logEntry?: LogEntry\n\n  constructor({ garden, service, force, forceBuild, logEntry }: DeployTaskParams) {\n    super({ garden, force, version: service.module.version })\n    this.service = service\n    this.forceBuild = forceBuild\n    this.logEntry = logEntry\n  }\n\n  async getDependencies() {\n    const serviceDeps = this.service.config.dependencies\n    const services = await this.garden.getServices(serviceDeps)\n\n    const deps: Task[] = await Bluebird.map(services, async (service) => {\n      return new DeployTask({\n        garden: this.garden,\n        service,\n        force: false,\n        forceBuild: this.forceBuild,\n      })\n    })\n\n    deps.push(new PushTask({\n      garden: this.garden,\n      module: this.service.module,\n      forceBuild: this.forceBuild,\n    }))\n\n    return deps\n  }\n\n  protected getName() {\n    return this.service.name\n  }\n\n  getDescription() {\n    return `deploying service ${this.service.name} (from module ${this.service.module.name})`\n  }\n\n  async process(): Promise<ServiceStatus> {\n    const logEntry = (this.logEntry || this.garden.log).info({\n      section: this.service.name,\n      msg: \"Checking status\",\n      status: \"active\",\n    })\n\n    // TODO: get version from build task results\n    const { versionString } = await this.service.module.version\n    const status = await this.garden.actions.getServiceStatus({ service: this.service, logEntry })\n\n    if (\n      !this.force &&\n      versionString === status.version &&\n      status.state === \"ready\"\n    ) {\n      // already deployed and ready\n      logEntry.setSuccess({\n        msg: `Version ${versionString} already deployed`,\n        append: true,\n      })\n      return status\n    }\n\n    logEntry.setState(\"Deploying\")\n\n    const dependencies = await this.garden.getServices(this.service.config.dependencies)\n\n    let result: ServiceStatus\n    try {\n      result = await this.garden.actions.deployService({\n        service: this.service,\n        runtimeContext: await prepareRuntimeContext(this.garden, this.service.module, dependencies),\n        logEntry,\n        force: this.force,\n      })\n    } catch (err) {\n      logEntry.setError()\n      throw err\n    }\n\n    logEntry.setSuccess({ msg: chalk.green(`Ready`), append: true })\n    return result\n  }\n}\n\nexport async function getDeployTasks(\n  { garden, module, serviceNames, force = false, forceBuild = false, includeDependants = false }:\n    {\n      garden: Garden, module: Module, serviceNames?: string[] | null,\n      force?: boolean, forceBuild?: boolean, includeDependants?: boolean,\n    },\n) {\n\n  const modulesToProcess = includeDependants\n    ? (await withDependants(garden, [module], await computeAutoReloadDependants(garden)))\n    : [module]\n\n  const moduleServices = flatten(await Bluebird.map(\n    modulesToProcess,\n    m => garden.getServices(getNames(m.serviceConfigs))))\n\n  const servicesToProcess = serviceNames\n    ? moduleServices.filter(s => serviceNames.includes(s.name))\n    : moduleServices\n\n  return servicesToProcess.map(service => new DeployTask({ garden, service, force, forceBuild }))\n}\n"]} diff --git a/garden-service/build/tasks/publish.d.ts b/garden-service/build/tasks/publish.d.ts new file mode 100644 index 00000000000..d1989991371 --- /dev/null +++ b/garden-service/build/tasks/publish.d.ts @@ -0,0 +1,21 @@ +import { BuildTask } from "./build"; +import { Module } from "../types/module"; +import { PublishResult } from "../types/plugin/outputs"; +import { Task } from "../tasks/base"; +import { Garden } from "../garden"; +export interface PublishTaskParams { + garden: Garden; + module: Module; + forceBuild: boolean; +} +export declare class PublishTask extends Task { + type: string; + private module; + private forceBuild; + constructor({ garden, module, forceBuild }: PublishTaskParams); + getDependencies(): Promise; + getName(): string; + getDescription(): string; + process(): Promise; +} +//# sourceMappingURL=publish.d.ts.map \ No newline at end of file diff --git a/garden-service/build/tasks/publish.js b/garden-service/build/tasks/publish.js new file mode 100644 index 00000000000..d644067a18c --- /dev/null +++ b/garden-service/build/tasks/publish.js @@ -0,0 +1,81 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const chalk_1 = require("chalk"); +const build_1 = require("./build"); +const base_1 = require("../tasks/base"); +class PublishTask extends base_1.Task { + constructor({ garden, module, forceBuild }) { + super({ garden, version: module.version }); + this.type = "publish"; + this.module = module; + this.forceBuild = forceBuild; + } + getDependencies() { + return __awaiter(this, void 0, void 0, function* () { + if (!this.module.allowPublish) { + return []; + } + return [new build_1.BuildTask({ + garden: this.garden, + module: this.module, + force: this.forceBuild, + })]; + }); + } + getName() { + return this.module.name; + } + getDescription() { + return `publishing module ${this.module.name}`; + } + process() { + return __awaiter(this, void 0, void 0, function* () { + if (!this.module.allowPublish) { + this.garden.log.info({ + section: this.module.name, + msg: "Publishing disabled", + status: "active", + }); + return { published: false }; + } + const logEntry = this.garden.log.info({ + section: this.module.name, + msg: "Publishing", + status: "active", + }); + let result; + try { + result = yield this.garden.actions.publishModule({ module: this.module, logEntry }); + } + catch (err) { + logEntry.setError(); + throw err; + } + if (result.published) { + logEntry.setSuccess({ msg: chalk_1.default.green(result.message || `Ready`), append: true }); + } + else { + logEntry.setWarn({ msg: result.message, append: true }); + } + return result; + }); + } +} +exports.PublishTask = PublishTask; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/tasks/push.d.ts b/garden-service/build/tasks/push.d.ts new file mode 100644 index 00000000000..b04b46dd3d8 --- /dev/null +++ b/garden-service/build/tasks/push.d.ts @@ -0,0 +1,21 @@ +import { BuildTask } from "./build"; +import { Module } from "../types/module"; +import { PushResult } from "../types/plugin/outputs"; +import { Task } from "../tasks/base"; +import { Garden } from "../garden"; +export interface PushTaskParams { + garden: Garden; + module: Module; + forceBuild: boolean; +} +export declare class PushTask extends Task { + type: string; + private module; + private forceBuild; + constructor({ garden, module, forceBuild }: PushTaskParams); + getDependencies(): Promise; + getName(): string; + getDescription(): string; + process(): Promise; +} +//# sourceMappingURL=push.d.ts.map \ No newline at end of file diff --git a/garden-service/build/tasks/push.js b/garden-service/build/tasks/push.js new file mode 100644 index 00000000000..a92625bcac7 --- /dev/null +++ b/garden-service/build/tasks/push.js @@ -0,0 +1,80 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const chalk_1 = require("chalk"); +const build_1 = require("./build"); +const base_1 = require("../tasks/base"); +class PushTask extends base_1.Task { + constructor({ garden, module, forceBuild }) { + super({ garden, version: module.version }); + this.type = "push"; + this.module = module; + this.forceBuild = forceBuild; + } + getDependencies() { + return __awaiter(this, void 0, void 0, function* () { + return [new build_1.BuildTask({ + garden: this.garden, + module: this.module, + force: this.forceBuild, + })]; + }); + } + getName() { + return this.module.name; + } + getDescription() { + return `pushing module ${this.module.name}`; + } + process() { + return __awaiter(this, void 0, void 0, function* () { + // avoid logging stuff if there is no push handler + const defaultHandler = () => __awaiter(this, void 0, void 0, function* () { return ({ pushed: false }); }); + const handler = yield this.garden.getModuleActionHandler({ + moduleType: this.module.type, + actionType: "pushModule", + defaultHandler, + }); + if (handler === defaultHandler) { + return { pushed: false }; + } + const logEntry = this.garden.log.info({ + section: this.module.name, + msg: "Pushing", + status: "active", + }); + let result; + try { + result = yield this.garden.actions.pushModule({ module: this.module, logEntry }); + } + catch (err) { + logEntry.setError(); + throw err; + } + if (result.pushed) { + logEntry.setSuccess({ msg: chalk_1.default.green(result.message || `Ready`), append: true }); + } + else if (result.message) { + logEntry.setWarn({ msg: result.message, append: true }); + } + return result; + }); + } +} +exports.PushTask = PushTask; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/tasks/test.d.ts b/garden-service/build/tasks/test.d.ts new file mode 100644 index 00000000000..4a6e5f15245 --- /dev/null +++ b/garden-service/build/tasks/test.d.ts @@ -0,0 +1,26 @@ +import { Module } from "../types/module"; +import { TestConfig } from "../config/test"; +import { TestResult } from "../types/plugin/outputs"; +import { Task, TaskParams } from "../tasks/base"; +import { Garden } from "../garden"; +export interface TestTaskParams { + garden: Garden; + module: Module; + testConfig: TestConfig; + force: boolean; + forceBuild: boolean; +} +export declare class TestTask extends Task { + type: string; + private module; + private testConfig; + private forceBuild; + constructor({ garden, module, testConfig, force, forceBuild, version }: TestTaskParams & TaskParams); + static factory(initArgs: TestTaskParams): Promise; + getDependencies(): Promise; + getName(): string; + getDescription(): string; + process(): Promise; + private getTestResult; +} +//# sourceMappingURL=test.d.ts.map \ No newline at end of file diff --git a/garden-service/build/tasks/test.js b/garden-service/build/tasks/test.js new file mode 100644 index 00000000000..f496f24f375 --- /dev/null +++ b/garden-service/build/tasks/test.js @@ -0,0 +1,146 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const chalk_1 = require("chalk"); +const build_1 = require("./build"); +const deploy_1 = require("./deploy"); +const base_1 = require("../tasks/base"); +const service_1 = require("../types/service"); +class TestError extends Error { + toString() { + return this.message; + } +} +class TestTask extends base_1.Task { + constructor({ garden, module, testConfig, force, forceBuild, version }) { + super({ garden, force, version }); + this.type = "test"; + this.module = module; + this.testConfig = testConfig; + this.force = force; + this.forceBuild = forceBuild; + } + static factory(initArgs) { + return __awaiter(this, void 0, void 0, function* () { + const { garden, module, testConfig } = initArgs; + const version = yield getTestVersion(garden, module, testConfig); + return new TestTask(Object.assign({}, initArgs, { version })); + }); + } + getDependencies() { + return __awaiter(this, void 0, void 0, function* () { + const testResult = yield this.getTestResult(); + if (testResult && testResult.success) { + return []; + } + const services = yield this.garden.getServices(this.testConfig.dependencies); + const deps = [new build_1.BuildTask({ + garden: this.garden, + module: this.module, + force: this.forceBuild, + })]; + for (const service of services) { + deps.push(new deploy_1.DeployTask({ + garden: this.garden, + service, + force: false, + forceBuild: this.forceBuild, + })); + } + return Bluebird.all(deps); + }); + } + getName() { + return `${this.module.name}.${this.testConfig.name}`; + } + getDescription() { + return `running ${this.testConfig.name} tests in module ${this.module.name}`; + } + process() { + return __awaiter(this, void 0, void 0, function* () { + // find out if module has already been tested + const testResult = yield this.getTestResult(); + if (testResult && testResult.success) { + const passedEntry = this.garden.log.info({ + section: this.module.name, + msg: `${this.testConfig.name} tests`, + }); + passedEntry.setSuccess({ msg: chalk_1.default.green("Already passed"), append: true }); + return testResult; + } + const entry = this.garden.log.info({ + section: this.module.name, + msg: `Running ${this.testConfig.name} tests`, + status: "active", + }); + const dependencies = yield getTestDependencies(this.garden, this.testConfig); + const runtimeContext = yield service_1.prepareRuntimeContext(this.garden, this.module, dependencies); + let result; + try { + result = yield this.garden.actions.testModule({ + interactive: false, + module: this.module, + runtimeContext, + silent: true, + testConfig: this.testConfig, + }); + } + catch (err) { + entry.setError(); + throw err; + } + if (result.success) { + entry.setSuccess({ msg: chalk_1.default.green(`Success`), append: true }); + } + else { + entry.setError({ msg: chalk_1.default.red(`Failed!`), append: true }); + throw new TestError(result.output); + } + return result; + }); + } + getTestResult() { + return __awaiter(this, void 0, void 0, function* () { + if (this.force) { + return null; + } + return this.garden.actions.getTestResult({ + module: this.module, + testName: this.testConfig.name, + version: this.version, + }); + }); + } +} +exports.TestTask = TestTask; +function getTestDependencies(garden, testConfig) { + return __awaiter(this, void 0, void 0, function* () { + return garden.getServices(testConfig.dependencies); + }); +} +/** + * Determine the version of the test run, based on the version of the module and each of its dependencies. + */ +function getTestVersion(garden, module, testConfig) { + return __awaiter(this, void 0, void 0, function* () { + const moduleDeps = yield garden.resolveModuleDependencies(module.build.dependencies, testConfig.dependencies); + return garden.resolveVersion(module.name, moduleDeps); + }); +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["tasks/test.ts"],"names":[],"mappings":"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","file":"tasks/test.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Bluebird from \"bluebird\"\nimport chalk from \"chalk\"\nimport { Module } from \"../types/module\"\nimport { TestConfig } from \"../config/test\"\nimport { ModuleVersion } from \"../vcs/base\"\nimport { BuildTask } from \"./build\"\nimport { DeployTask } from \"./deploy\"\nimport { TestResult } from \"../types/plugin/outputs\"\nimport { Task, TaskParams } from \"../tasks/base\"\nimport { prepareRuntimeContext } from \"../types/service\"\nimport { Garden } from \"../garden\"\n\nclass TestError extends Error {\n  toString() {\n    return this.message\n  }\n}\n\nexport interface TestTaskParams {\n  garden: Garden\n  module: Module\n  testConfig: TestConfig\n  force: boolean\n  forceBuild: boolean\n}\n\nexport class TestTask extends Task {\n  type = \"test\"\n\n  private module: Module\n  private testConfig: TestConfig\n  private forceBuild: boolean\n\n  constructor({ garden, module, testConfig, force, forceBuild, version }: TestTaskParams & TaskParams) {\n    super({ garden, force, version })\n    this.module = module\n    this.testConfig = testConfig\n    this.force = force\n    this.forceBuild = forceBuild\n  }\n\n  static async factory(initArgs: TestTaskParams): Promise<TestTask> {\n    const { garden, module, testConfig } = initArgs\n    const version = await getTestVersion(garden, module, testConfig)\n    return new TestTask({ ...initArgs, version })\n  }\n\n  async getDependencies() {\n    const testResult = await this.getTestResult()\n\n    if (testResult && testResult.success) {\n      return []\n    }\n\n    const services = await this.garden.getServices(this.testConfig.dependencies)\n\n    const deps: Task[] = [new BuildTask({\n      garden: this.garden,\n      module: this.module,\n      force: this.forceBuild,\n    })]\n\n    for (const service of services) {\n      deps.push(new DeployTask({\n        garden: this.garden,\n        service,\n        force: false,\n        forceBuild: this.forceBuild,\n      }))\n    }\n\n    return Bluebird.all(deps)\n  }\n\n  getName() {\n    return `${this.module.name}.${this.testConfig.name}`\n  }\n\n  getDescription() {\n    return `running ${this.testConfig.name} tests in module ${this.module.name}`\n  }\n\n  async process(): Promise<TestResult> {\n    // find out if module has already been tested\n    const testResult = await this.getTestResult()\n\n    if (testResult && testResult.success) {\n      const passedEntry = this.garden.log.info({\n        section: this.module.name,\n        msg: `${this.testConfig.name} tests`,\n      })\n      passedEntry.setSuccess({ msg: chalk.green(\"Already passed\"), append: true })\n      return testResult\n    }\n\n    const entry = this.garden.log.info({\n      section: this.module.name,\n      msg: `Running ${this.testConfig.name} tests`,\n      status: \"active\",\n    })\n\n    const dependencies = await getTestDependencies(this.garden, this.testConfig)\n    const runtimeContext = await prepareRuntimeContext(this.garden, this.module, dependencies)\n\n    let result: TestResult\n    try {\n      result = await this.garden.actions.testModule({\n        interactive: false,\n        module: this.module,\n        runtimeContext,\n        silent: true,\n        testConfig: this.testConfig,\n      })\n    } catch (err) {\n      entry.setError()\n      throw err\n    }\n    if (result.success) {\n      entry.setSuccess({ msg: chalk.green(`Success`), append: true })\n    } else {\n      entry.setError({ msg: chalk.red(`Failed!`), append: true })\n      throw new TestError(result.output)\n    }\n\n    return result\n  }\n\n  private async getTestResult() {\n    if (this.force) {\n      return null\n    }\n\n    return this.garden.actions.getTestResult({\n      module: this.module,\n      testName: this.testConfig.name,\n      version: this.version,\n    })\n  }\n}\n\nasync function getTestDependencies(garden: Garden, testConfig: TestConfig) {\n  return garden.getServices(testConfig.dependencies)\n}\n\n/**\n * Determine the version of the test run, based on the version of the module and each of its dependencies.\n */\nasync function getTestVersion(garden: Garden, module: Module, testConfig: TestConfig): Promise<ModuleVersion> {\n  const moduleDeps = await garden.resolveModuleDependencies(module.build.dependencies, testConfig.dependencies)\n  return garden.resolveVersion(module.name, moduleDeps)\n}\n"]} diff --git a/garden-service/build/template-string-parser.js b/garden-service/build/template-string-parser.js new file mode 100644 index 00000000000..4767ce995fc --- /dev/null +++ b/garden-service/build/template-string-parser.js @@ -0,0 +1,960 @@ +/* + * Generated by PEG.js 0.10.0. + * + * http://pegjs.org/ + */ + +"use strict"; + +function peg$subclass(child, parent) { + function ctor() { this.constructor = child; } + ctor.prototype = parent.prototype; + child.prototype = new ctor(); +} + +function peg$SyntaxError(message, expected, found, location) { + this.message = message; + this.expected = expected; + this.found = found; + this.location = location; + this.name = "SyntaxError"; + + if (typeof Error.captureStackTrace === "function") { + Error.captureStackTrace(this, peg$SyntaxError); + } +} + +peg$subclass(peg$SyntaxError, Error); + +peg$SyntaxError.buildMessage = function(expected, found) { + var DESCRIBE_EXPECTATION_FNS = { + literal: function(expectation) { + return "\"" + literalEscape(expectation.text) + "\""; + }, + + "class": function(expectation) { + var escapedParts = "", + i; + + for (i = 0; i < expectation.parts.length; i++) { + escapedParts += expectation.parts[i] instanceof Array + ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1]) + : classEscape(expectation.parts[i]); + } + + return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]"; + }, + + any: function(expectation) { + return "any character"; + }, + + end: function(expectation) { + return "end of input"; + }, + + other: function(expectation) { + return expectation.description; + } + }; + + function hex(ch) { + return ch.charCodeAt(0).toString(16).toUpperCase(); + } + + function literalEscape(s) { + return s + .replace(/\\/g, '\\\\') + .replace(/"/g, '\\"') + .replace(/\0/g, '\\0') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); }); + } + + function classEscape(s) { + return s + .replace(/\\/g, '\\\\') + .replace(/\]/g, '\\]') + .replace(/\^/g, '\\^') + .replace(/-/g, '\\-') + .replace(/\0/g, '\\0') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); }); + } + + function describeExpectation(expectation) { + return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); + } + + function describeExpected(expected) { + var descriptions = new Array(expected.length), + i, j; + + for (i = 0; i < expected.length; i++) { + descriptions[i] = describeExpectation(expected[i]); + } + + descriptions.sort(); + + if (descriptions.length > 0) { + for (i = 1, j = 1; i < descriptions.length; i++) { + if (descriptions[i - 1] !== descriptions[i]) { + descriptions[j] = descriptions[i]; + j++; + } + } + descriptions.length = j; + } + + switch (descriptions.length) { + case 1: + return descriptions[0]; + + case 2: + return descriptions[0] + " or " + descriptions[1]; + + default: + return descriptions.slice(0, -1).join(", ") + + ", or " + + descriptions[descriptions.length - 1]; + } + } + + function describeFound(found) { + return found ? "\"" + literalEscape(found) + "\"" : "end of input"; + } + + return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; +}; + +function peg$parse(input, options) { + options = options !== void 0 ? options : {}; + + var peg$FAILED = {}, + + peg$startRuleFunctions = { TemplateString: peg$parseTemplateString }, + peg$startRuleFunction = peg$parseTemplateString, + + peg$c0 = function(a, b) { return [...a, ...(b || [])] }, + peg$c1 = function(a, b, c) { return [a, ...b, ...(c || [])] }, + peg$c2 = peg$anyExpectation(), + peg$c3 = function() { return [text()] }, + peg$c4 = function(head, tail) { + const parts = [["", head]].concat(tail).map(p => p[1]) + return options.getKey(parts) + }, + peg$c5 = function(s) { + return options.resolve(s) + }, + peg$c6 = function() { + throw new options.TemplateStringError("Invalid template string: ..." + text()) + }, + peg$c7 = "${", + peg$c8 = peg$literalExpectation("${", false), + peg$c9 = "}", + peg$c10 = peg$literalExpectation("}", false), + peg$c11 = /^[a-zA-Z]/, + peg$c12 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false), + peg$c13 = /^[a-zA-Z0-9_\-]/, + peg$c14 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false), + peg$c15 = function() { return text() }, + peg$c16 = ".", + peg$c17 = peg$literalExpectation(".", false), + + peg$currPos = 0, + peg$savedPos = 0, + peg$posDetailsCache = [{ line: 1, column: 1 }], + peg$maxFailPos = 0, + peg$maxFailExpected = [], + peg$silentFails = 0, + + peg$result; + + if ("startRule" in options) { + if (!(options.startRule in peg$startRuleFunctions)) { + throw new Error("Can't start parsing from rule \"" + options.startRule + "\"."); + } + + peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; + } + + function text() { + return input.substring(peg$savedPos, peg$currPos); + } + + function location() { + return peg$computeLocation(peg$savedPos, peg$currPos); + } + + function expected(description, location) { + location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos) + + throw peg$buildStructuredError( + [peg$otherExpectation(description)], + input.substring(peg$savedPos, peg$currPos), + location + ); + } + + function error(message, location) { + location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos) + + throw peg$buildSimpleError(message, location); + } + + function peg$literalExpectation(text, ignoreCase) { + return { type: "literal", text: text, ignoreCase: ignoreCase }; + } + + function peg$classExpectation(parts, inverted, ignoreCase) { + return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase }; + } + + function peg$anyExpectation() { + return { type: "any" }; + } + + function peg$endExpectation() { + return { type: "end" }; + } + + function peg$otherExpectation(description) { + return { type: "other", description: description }; + } + + function peg$computePosDetails(pos) { + var details = peg$posDetailsCache[pos], p; + + if (details) { + return details; + } else { + p = pos - 1; + while (!peg$posDetailsCache[p]) { + p--; + } + + details = peg$posDetailsCache[p]; + details = { + line: details.line, + column: details.column + }; + + while (p < pos) { + if (input.charCodeAt(p) === 10) { + details.line++; + details.column = 1; + } else { + details.column++; + } + + p++; + } + + peg$posDetailsCache[pos] = details; + return details; + } + } + + function peg$computeLocation(startPos, endPos) { + var startPosDetails = peg$computePosDetails(startPos), + endPosDetails = peg$computePosDetails(endPos); + + return { + start: { + offset: startPos, + line: startPosDetails.line, + column: startPosDetails.column + }, + end: { + offset: endPos, + line: endPosDetails.line, + column: endPosDetails.column + } + }; + } + + function peg$fail(expected) { + if (peg$currPos < peg$maxFailPos) { return; } + + if (peg$currPos > peg$maxFailPos) { + peg$maxFailPos = peg$currPos; + peg$maxFailExpected = []; + } + + peg$maxFailExpected.push(expected); + } + + function peg$buildSimpleError(message, location) { + return new peg$SyntaxError(message, null, null, location); + } + + function peg$buildStructuredError(expected, found, location) { + return new peg$SyntaxError( + peg$SyntaxError.buildMessage(expected, found), + expected, + found, + location + ); + } + + function peg$parseTemplateString() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseFormatString(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseFormatString(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseTemplateString(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c0(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsePrefix(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseFormatString(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseFormatString(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseTemplateString(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c1(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseInvalidFormatString(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$currPos; + s2 = []; + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c2); } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c2); } + } + } + if (s2 !== peg$FAILED) { + s1 = input.substring(s1, peg$currPos); + } else { + s1 = s2; + } + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c3(); + } + s0 = s1; + } + } + } + + return s0; + } + + function peg$parseNestedTemplateString() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + s1 = []; + s2 = peg$parseFormatString(); + if (s2 !== peg$FAILED) { + while (s2 !== peg$FAILED) { + s1.push(s2); + s2 = peg$parseFormatString(); + } + } else { + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseNestedTemplateString(); + if (s2 === peg$FAILED) { + s2 = null; + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c0(s1, s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parsePrefix(); + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$parseFormatString(); + if (s3 !== peg$FAILED) { + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$parseFormatString(); + } + } else { + s2 = peg$FAILED; + } + if (s2 !== peg$FAILED) { + s3 = peg$parseNestedTemplateString(); + if (s3 === peg$FAILED) { + s3 = null; + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c1(s1, s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$parseInvalidFormatString(); + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseSuffix(); + if (s1 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c3(); + } + s0 = s1; + } + } + } + + return s0; + } + + function peg$parseFormatString() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$parseFormatStart(); + if (s1 !== peg$FAILED) { + s2 = peg$parseIdentifier(); + if (s2 !== peg$FAILED) { + s3 = []; + s4 = peg$currPos; + s5 = peg$parseKeySeparator(); + if (s5 !== peg$FAILED) { + s6 = peg$parseIdentifier(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + while (s4 !== peg$FAILED) { + s3.push(s4); + s4 = peg$currPos; + s5 = peg$parseKeySeparator(); + if (s5 !== peg$FAILED) { + s6 = peg$parseIdentifier(); + if (s6 !== peg$FAILED) { + s5 = [s5, s6]; + s4 = s5; + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } else { + peg$currPos = s4; + s4 = peg$FAILED; + } + } + if (s3 !== peg$FAILED) { + s4 = peg$parseFormatEnd(); + if (s4 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c4(s2, s3); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + if (s0 === peg$FAILED) { + s0 = peg$currPos; + s1 = peg$parseFormatStart(); + if (s1 !== peg$FAILED) { + s2 = peg$parseNestedTemplateString(); + if (s2 !== peg$FAILED) { + s3 = peg$parseFormatEnd(); + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c5(s2); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } + + return s0; + } + + function peg$parseInvalidFormatString() { + var s0, s1, s2, s3, s4; + + s0 = peg$currPos; + s1 = peg$parsePrefix(); + if (s1 === peg$FAILED) { + s1 = null; + } + if (s1 !== peg$FAILED) { + s2 = peg$parseFormatStart(); + if (s2 !== peg$FAILED) { + s3 = []; + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c2); } + } + while (s4 !== peg$FAILED) { + s3.push(s4); + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c2); } + } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c6(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseFormatStart() { + var s0; + + if (input.substr(peg$currPos, 2) === peg$c7) { + s0 = peg$c7; + peg$currPos += 2; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c8); } + } + + return s0; + } + + function peg$parseFormatEnd() { + var s0; + + if (input.charCodeAt(peg$currPos) === 125) { + s0 = peg$c9; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c10); } + } + + return s0; + } + + function peg$parseIdentifier() { + var s0, s1, s2, s3; + + s0 = peg$currPos; + if (peg$c11.test(input.charAt(peg$currPos))) { + s1 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s1 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c12); } + } + if (s1 !== peg$FAILED) { + s2 = []; + if (peg$c13.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c14); } + } + while (s3 !== peg$FAILED) { + s2.push(s3); + if (peg$c13.test(input.charAt(peg$currPos))) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c14); } + } + } + if (s2 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c15(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseKeySeparator() { + var s0; + + if (input.charCodeAt(peg$currPos) === 46) { + s0 = peg$c16; + peg$currPos++; + } else { + s0 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c17); } + } + + return s0; + } + + function peg$parsePrefix() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parseFormatStart(); + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c2); } + } + if (s4 !== peg$FAILED) { + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseFormatStart(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c2); } + } + if (s4 !== peg$FAILED) { + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseFormatStart(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c2); } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c15(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + function peg$parseSuffix() { + var s0, s1, s2, s3, s4, s5, s6; + + s0 = peg$currPos; + s1 = peg$currPos; + peg$silentFails++; + s2 = peg$parseFormatEnd(); + peg$silentFails--; + if (s2 === peg$FAILED) { + s1 = void 0; + } else { + peg$currPos = s1; + s1 = peg$FAILED; + } + if (s1 !== peg$FAILED) { + s2 = []; + s3 = peg$currPos; + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c2); } + } + if (s4 !== peg$FAILED) { + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseFormatEnd(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + while (s3 !== peg$FAILED) { + s2.push(s3); + s3 = peg$currPos; + if (input.length > peg$currPos) { + s4 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s4 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c2); } + } + if (s4 !== peg$FAILED) { + s5 = peg$currPos; + peg$silentFails++; + s6 = peg$parseFormatEnd(); + peg$silentFails--; + if (s6 === peg$FAILED) { + s5 = void 0; + } else { + peg$currPos = s5; + s5 = peg$FAILED; + } + if (s5 !== peg$FAILED) { + s4 = [s4, s5]; + s3 = s4; + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } else { + peg$currPos = s3; + s3 = peg$FAILED; + } + } + if (s2 !== peg$FAILED) { + if (input.length > peg$currPos) { + s3 = input.charAt(peg$currPos); + peg$currPos++; + } else { + s3 = peg$FAILED; + if (peg$silentFails === 0) { peg$fail(peg$c2); } + } + if (s3 !== peg$FAILED) { + peg$savedPos = s0; + s1 = peg$c15(); + s0 = s1; + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + } else { + peg$currPos = s0; + s0 = peg$FAILED; + } + + return s0; + } + + peg$result = peg$startRuleFunction(); + + if (peg$result !== peg$FAILED && peg$currPos === input.length) { + return peg$result; + } else { + if (peg$result !== peg$FAILED && peg$currPos < input.length) { + peg$fail(peg$endExpectation()); + } + + throw peg$buildStructuredError( + peg$maxFailExpected, + peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, + peg$maxFailPos < input.length + ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) + : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) + ); + } +} + +module.exports = { + SyntaxError: peg$SyntaxError, + parse: peg$parse +}; diff --git a/garden-service/build/template-string.d.ts b/garden-service/build/template-string.d.ts new file mode 100644 index 00000000000..cba75cddd3d --- /dev/null +++ b/garden-service/build/template-string.d.ts @@ -0,0 +1,16 @@ +import { ConfigContext } from "./config/config-context"; +export declare type StringOrStringPromise = Promise | string; +/** + * Parse and resolve a templated string, with the given context. The template format is similar to native JS templated + * strings but only supports simple lookups from the given context, e.g. "prefix-${nested.key}-suffix", and not + * arbitrary JS code. + * + * The context should be a ConfigContext instance. The optional `stack` parameter is used to detect circular + * dependencies when resolving context variables. + */ +export declare function resolveTemplateString(string: string, context: ConfigContext, stack?: string[]): Promise; +/** + * Recursively parses and resolves all templated strings in the given object. + */ +export declare function resolveTemplateStrings(obj: T, context: ConfigContext): Promise; +//# sourceMappingURL=template-string.d.ts.map \ No newline at end of file diff --git a/garden-service/build/template-string.js b/garden-service/build/template-string.js new file mode 100644 index 00000000000..53f4e359cff --- /dev/null +++ b/garden-service/build/template-string.js @@ -0,0 +1,84 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_extra_1 = require("fs-extra"); +const path_1 = require("path"); +const Bluebird = require("bluebird"); +const util_1 = require("./util/util"); +const exceptions_1 = require("./exceptions"); +class TemplateStringError extends exceptions_1.GardenBaseError { + constructor() { + super(...arguments); + this.type = "template-string"; + } +} +let _parser; +function getParser() { + return __awaiter(this, void 0, void 0, function* () { + if (!_parser) { + try { + _parser = require("./template-string-parser"); + } + catch (_err) { + // fallback for when running with ts-node or mocha + const peg = require("pegjs"); + const pegFilePath = path_1.resolve(__dirname, "template-string-parser.pegjs"); + const grammar = yield fs_extra_1.readFile(pegFilePath); + _parser = peg.generate(grammar.toString(), { trace: false }); + } + } + return _parser; + }); +} +/** + * Parse and resolve a templated string, with the given context. The template format is similar to native JS templated + * strings but only supports simple lookups from the given context, e.g. "prefix-${nested.key}-suffix", and not + * arbitrary JS code. + * + * The context should be a ConfigContext instance. The optional `stack` parameter is used to detect circular + * dependencies when resolving context variables. + */ +function resolveTemplateString(string, context, stack) { + return __awaiter(this, void 0, void 0, function* () { + const parser = yield getParser(); + const parsed = parser.parse(string, { + getKey: (key) => __awaiter(this, void 0, void 0, function* () { return context.resolve({ key, nodePath: [], stack }); }), + // need this to allow nested template strings + resolve: (parts) => __awaiter(this, void 0, void 0, function* () { + const s = (yield Bluebird.all(parts)).join(""); + return resolveTemplateString(`\$\{${s}\}`, context, stack); + }), + TemplateStringError, + }); + const resolved = yield Bluebird.all(parsed); + return resolved.join(""); + }); +} +exports.resolveTemplateString = resolveTemplateString; +/** + * Recursively parses and resolves all templated strings in the given object. + */ +function resolveTemplateStrings(obj, context) { + return __awaiter(this, void 0, void 0, function* () { + return util_1.asyncDeepMap(obj, (v) => typeof v === "string" ? resolveTemplateString(v, context) : v, + // need to iterate sequentially to catch potential circular dependencies + { concurrency: 1 }); + }); +} +exports.resolveTemplateStrings = resolveTemplateStrings; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/types/module.d.ts b/garden-service/build/types/module.d.ts new file mode 100644 index 00000000000..666bcf44253 --- /dev/null +++ b/garden-service/build/types/module.d.ts @@ -0,0 +1,30 @@ +import { TestSpec } from "../config/test"; +import { ModuleSpec, ModuleConfig } from "../config/module"; +import { ServiceSpec } from "../config/service"; +import { ModuleVersion } from "../vcs/base"; +import { Garden } from "../garden"; +import { Service } from "./service"; +import * as Joi from "joi"; +export interface BuildCopySpec { + source: string; + target: string; +} +export interface Module extends ModuleConfig { + buildPath: string; + version: ModuleVersion; + services: Service>[]; + serviceNames: string[]; + serviceDependencyNames: string[]; + _ConfigType: ModuleConfig; +} +export declare const moduleSchema: Joi.ObjectSchema; +export interface ModuleMap { + [key: string]: T; +} +export interface ModuleConfigMap { + [key: string]: T; +} +export declare function moduleFromConfig(garden: Garden, config: ModuleConfig): Promise; +export declare function getModuleCacheContext(config: ModuleConfig): string[]; +export declare function getModuleKey(name: string, plugin?: string): string; +//# sourceMappingURL=module.d.ts.map \ No newline at end of file diff --git a/garden-service/build/types/module.js b/garden-service/build/types/module.js new file mode 100644 index 00000000000..2bc99d6c238 --- /dev/null +++ b/garden-service/build/types/module.js @@ -0,0 +1,63 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const util_1 = require("../util/util"); +const module_1 = require("../config/module"); +const base_1 = require("../vcs/base"); +const cache_1 = require("../cache"); +const service_1 = require("./service"); +const Joi = require("joi"); +const common_1 = require("../config/common"); +exports.moduleSchema = module_1.moduleConfigSchema + .keys({ + buildPath: Joi.string() + .required() + .uri({ relativeOnly: true }) + .description("The path to the build staging directory for the module."), + version: base_1.moduleVersionSchema + .required(), + services: common_1.joiArray(Joi.lazy(() => service_1.serviceSchema)) + .required() + .description("A list of all the services that the module provides."), + serviceNames: common_1.joiArray(common_1.joiIdentifier()) + .required() + .description("The names of the services that the module provides."), + serviceDependencyNames: common_1.joiArray(common_1.joiIdentifier()) + .required() + .description("The names of all the services that the services in this module depend on."), +}); +function moduleFromConfig(garden, config) { + return __awaiter(this, void 0, void 0, function* () { + const module = Object.assign({}, config, { buildPath: yield garden.buildDir.buildPath(config.name), version: yield garden.resolveVersion(config.name, config.build.dependencies), services: [], serviceNames: util_1.getNames(config.serviceConfigs), serviceDependencyNames: lodash_1.uniq(lodash_1.flatten(config.serviceConfigs + .map(serviceConfig => serviceConfig.dependencies) + .filter(deps => !!deps))), _ConfigType: config }); + module.services = config.serviceConfigs.map(serviceConfig => service_1.serviceFromConfig(module, serviceConfig)); + return module; + }); +} +exports.moduleFromConfig = moduleFromConfig; +function getModuleCacheContext(config) { + return cache_1.pathToCacheContext(config.path); +} +exports.getModuleCacheContext = getModuleCacheContext; +function getModuleKey(name, plugin) { + return plugin ? `${plugin}--${name}` : name; +} +exports.getModuleKey = getModuleKey; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/types/plugin/outputs.d.ts b/garden-service/build/types/plugin/outputs.d.ts new file mode 100644 index 00000000000..53c29aa9bfb --- /dev/null +++ b/garden-service/build/types/plugin/outputs.d.ts @@ -0,0 +1,121 @@ +import * as Joi from "joi"; +import { ModuleVersion } from "../../vcs/base"; +import { PrimitiveMap } from "../../config/common"; +import { Module } from "../module"; +import { ServiceStatus } from "../service"; +import { ModuleConfig } from "../../config/module"; +export interface EnvironmentStatus { + ready: boolean; + needUserInput?: boolean; + detail?: any; +} +export declare const environmentStatusSchema: Joi.ObjectSchema; +export declare type EnvironmentStatusMap = { + [key: string]: EnvironmentStatus; +}; +export interface PrepareEnvironmentResult { +} +export declare const prepareEnvironmentResultSchema: Joi.ObjectSchema; +export interface CleanupEnvironmentResult { +} +export declare const cleanupEnvironmentResultSchema: Joi.ObjectSchema; +export interface GetSecretResult { + value: string | null; +} +export declare const getSecretResultSchema: Joi.ObjectSchema; +export interface SetSecretResult { +} +export declare const setSecretResultSchema: Joi.ObjectSchema; +export interface DeleteSecretResult { + found: boolean; +} +export declare const deleteSecretResultSchema: Joi.ObjectSchema; +export interface ExecInServiceResult { + code: number; + output: string; + stdout?: string; + stderr?: string; +} +export declare const execInServiceResultSchema: Joi.ObjectSchema; +export interface ServiceLogEntry { + serviceName: string; + timestamp: Date; + msg: string; +} +export declare const serviceLogEntrySchema: Joi.ObjectSchema; +export interface GetServiceLogsResult { +} +export declare const getServiceLogsResultSchema: Joi.ObjectSchema; +export interface ModuleTypeDescription { + docs: string; + schema: object; +} +export declare const moduleTypeDescriptionSchema: Joi.ObjectSchema; +export declare type ValidateModuleResult = ModuleConfig; +export declare const validateModuleResultSchema: Joi.ObjectSchema; +export interface BuildResult { + buildLog?: string; + fetched?: boolean; + fresh?: boolean; + version?: string; + details?: any; +} +export declare const buildModuleResultSchema: Joi.ObjectSchema; +export interface PushResult { + pushed: boolean; + message?: string; +} +export declare const pushModuleResultSchema: Joi.ObjectSchema; +export interface PublishResult { + published: boolean; + message?: string; +} +export declare const publishModuleResultSchema: Joi.ObjectSchema; +export interface RunResult { + moduleName: string; + command: string[]; + version: ModuleVersion; + success: boolean; + startedAt: Date; + completedAt: Date; + output: string; +} +export declare const runResultSchema: Joi.ObjectSchema; +export interface TestResult extends RunResult { + testName: string; +} +export declare const testResultSchema: Joi.ObjectSchema; +export declare const getTestResultSchema: Joi.ObjectSchema; +export interface BuildStatus { + ready: boolean; +} +export declare const buildStatusSchema: Joi.ObjectSchema; +export interface PluginActionOutputs { + getEnvironmentStatus: Promise; + prepareEnvironment: Promise; + cleanupEnvironment: Promise; + getSecret: Promise; + setSecret: Promise; + deleteSecret: Promise; +} +export interface ServiceActionOutputs { + getServiceStatus: Promise; + deployService: Promise; + deleteService: Promise; + getServiceOutputs: Promise; + execInService: Promise; + getServiceLogs: Promise<{}>; + runService: Promise; +} +export interface ModuleActionOutputs extends ServiceActionOutputs { + describeType: Promise; + validate: Promise; + getBuildStatus: Promise; + build: Promise; + pushModule: Promise; + publishModule: Promise; + runModule: Promise; + testModule: Promise; + getTestResult: Promise; +} +//# sourceMappingURL=outputs.d.ts.map \ No newline at end of file diff --git a/garden-service/build/types/plugin/outputs.js b/garden-service/build/types/plugin/outputs.js new file mode 100644 index 00000000000..dc602ac6121 --- /dev/null +++ b/garden-service/build/types/plugin/outputs.js @@ -0,0 +1,145 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const base_1 = require("../../vcs/base"); +const module_1 = require("../../config/module"); +exports.environmentStatusSchema = Joi.object() + .keys({ + ready: Joi.boolean() + .required() + .description("Set to true if the environment is fully configured for a provider."), + needUserInput: Joi.boolean() + .description("Set to true if the environment needs user input to be initialized, " + + "and thus needs to be initialized via `garden init`."), + detail: Joi.object() + .meta({ extendable: true }) + .description("Use this to include additional information that is specific to the provider."), +}) + .description("Description of an environment's status for a provider."); +exports.prepareEnvironmentResultSchema = Joi.object().keys({}); +exports.cleanupEnvironmentResultSchema = Joi.object().keys({}); +exports.getSecretResultSchema = Joi.object() + .keys({ + value: Joi.string() + .allow(null) + .required() + .description("The config value found for the specified key (as string), or null if not found."), +}); +exports.setSecretResultSchema = Joi.object().keys({}); +exports.deleteSecretResultSchema = Joi.object() + .keys({ + found: Joi.boolean() + .required() + .description("Set to true if the key was deleted, false if it was not found."), +}); +exports.execInServiceResultSchema = Joi.object() + .keys({ + code: Joi.number() + .required() + .description("The exit code of the command executed in the service container."), + output: Joi.string() + .required() + .description("The output of the executed command."), + stdout: Joi.string() + .description("The stdout output of the executed command (if available)."), + stderr: Joi.string() + .description("The stderr output of the executed command (if available)."), +}); +exports.serviceLogEntrySchema = Joi.object() + .keys({ + serviceName: Joi.string() + .required() + .description("The name of the service the log entry originated from."), + timestamp: Joi.date() + .required() + .description("The time when the log entry was generated by the service."), + msg: Joi.string() + .required() + .description("The content of the log entry."), +}) + .description("A log entry returned by a getServiceLogs action handler."); +exports.getServiceLogsResultSchema = Joi.object().keys({}); +exports.moduleTypeDescriptionSchema = Joi.object() + .keys({ + docs: Joi.string() + .required() + .description("Documentation for the module type, in markdown format."), + schema: Joi.object() + .required() + .description("A valid OpenAPI schema describing the configuration keys for the `module` field in the module's `garden.yml`."), +}); +exports.validateModuleResultSchema = module_1.moduleConfigSchema; +exports.buildModuleResultSchema = Joi.object() + .keys({ + buildLog: Joi.string() + .allow("") + .description("The full log from the build."), + fetched: Joi.boolean() + .description("Set to true if the build was fetched from a remote registry."), + fresh: Joi.boolean() + .description("Set to true if the build was perfomed, false if it was already built, or fetched from a registry"), + version: Joi.string() + .description("The version that was built."), + details: Joi.object() + .description("Additional information, specific to the provider."), +}); +exports.pushModuleResultSchema = Joi.object() + .keys({ + pushed: Joi.boolean() + .required() + .description("Set to true if the module was pushed."), + message: Joi.string() + .description("Optional result message."), +}); +exports.publishModuleResultSchema = Joi.object() + .keys({ + published: Joi.boolean() + .required() + .description("Set to true if the module was published."), + message: Joi.string() + .description("Optional result message."), +}); +exports.runResultSchema = Joi.object() + .keys({ + moduleName: Joi.string() + .description("The name of the module that was run."), + command: Joi.array().items(Joi.string()) + .required() + .description("The command that was run in the module."), + version: base_1.moduleVersionSchema, + success: Joi.boolean() + .required() + .description("Whether the module was successfully run."), + startedAt: Joi.date() + .required() + .description("When the module run was started."), + completedAt: Joi.date() + .required() + .description("When the module run was completed."), + output: Joi.string() + .required() + .allow("") + .description("The output log from the run."), +}); +exports.testResultSchema = exports.runResultSchema + .keys({ + testName: Joi.string() + .required() + .description("The name of the test that was run."), +}); +exports.getTestResultSchema = exports.testResultSchema.allow(null); +exports.buildStatusSchema = Joi.object() + .keys({ + ready: Joi.boolean() + .required() + .description("Whether an up-to-date build is ready for the module."), +}); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["types/plugin/outputs.ts"],"names":[],"mappings":"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","file":"types/plugin/outputs.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Joi from \"joi\"\nimport { ModuleVersion, moduleVersionSchema } from \"../../vcs/base\"\nimport { PrimitiveMap } from \"../../config/common\"\nimport { Module } from \"../module\"\nimport { ServiceStatus } from \"../service\"\nimport { moduleConfigSchema, ModuleConfig } from \"../../config/module\"\n\nexport interface EnvironmentStatus {\n  ready: boolean\n  needUserInput?: boolean\n  detail?: any\n}\n\nexport const environmentStatusSchema = Joi.object()\n  .keys({\n    ready: Joi.boolean()\n      .required()\n      .description(\"Set to true if the environment is fully configured for a provider.\"),\n    needUserInput: Joi.boolean()\n      .description(\n        \"Set to true if the environment needs user input to be initialized, \" +\n        \"and thus needs to be initialized via `garden init`.\",\n      ),\n    detail: Joi.object()\n      .meta({ extendable: true })\n      .description(\"Use this to include additional information that is specific to the provider.\"),\n  })\n  .description(\"Description of an environment's status for a provider.\")\n\nexport type EnvironmentStatusMap = {\n  [key: string]: EnvironmentStatus,\n}\n\nexport interface PrepareEnvironmentResult { }\n\nexport const prepareEnvironmentResultSchema = Joi.object().keys({})\n\nexport interface CleanupEnvironmentResult { }\n\nexport const cleanupEnvironmentResultSchema = Joi.object().keys({})\n\nexport interface GetSecretResult {\n  value: string | null\n}\n\nexport const getSecretResultSchema = Joi.object()\n  .keys({\n    value: Joi.string()\n      .allow(null)\n      .required()\n      .description(\"The config value found for the specified key (as string), or null if not found.\"),\n  })\n\nexport interface SetSecretResult { }\n\nexport const setSecretResultSchema = Joi.object().keys({})\n\nexport interface DeleteSecretResult {\n  found: boolean\n}\n\nexport const deleteSecretResultSchema = Joi.object()\n  .keys({\n    found: Joi.boolean()\n      .required()\n      .description(\"Set to true if the key was deleted, false if it was not found.\"),\n  })\n\nexport interface ExecInServiceResult {\n  code: number\n  output: string\n  stdout?: string\n  stderr?: string\n}\n\nexport const execInServiceResultSchema = Joi.object()\n  .keys({\n    code: Joi.number()\n      .required()\n      .description(\"The exit code of the command executed in the service container.\"),\n    output: Joi.string()\n      .required()\n      .description(\"The output of the executed command.\"),\n    stdout: Joi.string()\n      .description(\"The stdout output of the executed command (if available).\"),\n    stderr: Joi.string()\n      .description(\"The stderr output of the executed command (if available).\"),\n  })\n\nexport interface ServiceLogEntry {\n  serviceName: string\n  timestamp: Date\n  msg: string\n}\n\nexport const serviceLogEntrySchema = Joi.object()\n  .keys({\n    serviceName: Joi.string()\n      .required()\n      .description(\"The name of the service the log entry originated from.\"),\n    timestamp: Joi.date()\n      .required()\n      .description(\"The time when the log entry was generated by the service.\"),\n    msg: Joi.string()\n      .required()\n      .description(\"The content of the log entry.\"),\n  })\n  .description(\"A log entry returned by a getServiceLogs action handler.\")\n\nexport interface GetServiceLogsResult { }\n\nexport const getServiceLogsResultSchema = Joi.object().keys({})\n\nexport interface ModuleTypeDescription {\n  docs: string\n  schema: object\n}\n\nexport const moduleTypeDescriptionSchema = Joi.object()\n  .keys({\n    docs: Joi.string()\n      .required()\n      .description(\"Documentation for the module type, in markdown format.\"),\n    schema: Joi.object()\n      .required()\n      .description(\n        \"A valid OpenAPI schema describing the configuration keys for the `module` field in the module's `garden.yml`.\",\n      ),\n  })\n\nexport type ValidateModuleResult<T extends Module = Module> =\n  ModuleConfig<T[\"spec\"], T[\"serviceConfigs\"][0][\"spec\"], T[\"testConfigs\"][0][\"spec\"]>\n\nexport const validateModuleResultSchema = moduleConfigSchema\n\nexport interface BuildResult {\n  buildLog?: string\n  fetched?: boolean\n  fresh?: boolean\n  version?: string\n  details?: any\n}\nexport const buildModuleResultSchema = Joi.object()\n  .keys({\n    buildLog: Joi.string()\n      .allow(\"\")\n      .description(\"The full log from the build.\"),\n    fetched: Joi.boolean()\n      .description(\"Set to true if the build was fetched from a remote registry.\"),\n    fresh: Joi.boolean()\n      .description(\"Set to true if the build was perfomed, false if it was already built, or fetched from a registry\"),\n    version: Joi.string()\n      .description(\"The version that was built.\"),\n    details: Joi.object()\n      .description(\"Additional information, specific to the provider.\"),\n  })\n\nexport interface PushResult {\n  pushed: boolean\n  message?: string\n}\nexport const pushModuleResultSchema = Joi.object()\n  .keys({\n    pushed: Joi.boolean()\n      .required()\n      .description(\"Set to true if the module was pushed.\"),\n    message: Joi.string()\n      .description(\"Optional result message.\"),\n  })\n\nexport interface PublishResult {\n  published: boolean\n  message?: string\n}\nexport const publishModuleResultSchema = Joi.object()\n  .keys({\n    published: Joi.boolean()\n      .required()\n      .description(\"Set to true if the module was published.\"),\n    message: Joi.string()\n      .description(\"Optional result message.\"),\n  })\n\nexport interface RunResult {\n  moduleName: string\n  command: string[]\n  version: ModuleVersion\n  success: boolean\n  startedAt: Date\n  completedAt: Date\n  output: string\n}\n\nexport const runResultSchema = Joi.object()\n  .keys({\n    moduleName: Joi.string()\n      .description(\"The name of the module that was run.\"),\n    command: Joi.array().items(Joi.string())\n      .required()\n      .description(\"The command that was run in the module.\"),\n    version: moduleVersionSchema,\n    success: Joi.boolean()\n      .required()\n      .description(\"Whether the module was successfully run.\"),\n    startedAt: Joi.date()\n      .required()\n      .description(\"When the module run was started.\"),\n    completedAt: Joi.date()\n      .required()\n      .description(\"When the module run was completed.\"),\n    output: Joi.string()\n      .required()\n      .allow(\"\")\n      .description(\"The output log from the run.\"),\n  })\n\nexport interface TestResult extends RunResult {\n  testName: string\n}\n\nexport const testResultSchema = runResultSchema\n  .keys({\n    testName: Joi.string()\n      .required()\n      .description(\"The name of the test that was run.\"),\n  })\n\nexport const getTestResultSchema = testResultSchema.allow(null)\n\nexport interface BuildStatus {\n  ready: boolean\n}\n\nexport const buildStatusSchema = Joi.object()\n  .keys({\n    ready: Joi.boolean()\n      .required()\n      .description(\"Whether an up-to-date build is ready for the module.\"),\n  })\n\nexport interface PluginActionOutputs {\n  getEnvironmentStatus: Promise<EnvironmentStatus>\n  prepareEnvironment: Promise<PrepareEnvironmentResult>\n  cleanupEnvironment: Promise<CleanupEnvironmentResult>\n\n  getSecret: Promise<GetSecretResult>\n  setSecret: Promise<SetSecretResult>\n  deleteSecret: Promise<DeleteSecretResult>\n}\n\nexport interface ServiceActionOutputs {\n  getServiceStatus: Promise<ServiceStatus>\n  deployService: Promise<ServiceStatus>\n  deleteService: Promise<ServiceStatus>\n  getServiceOutputs: Promise<PrimitiveMap>\n  execInService: Promise<ExecInServiceResult>\n  getServiceLogs: Promise<{}>\n  runService: Promise<RunResult>\n}\n\nexport interface ModuleActionOutputs extends ServiceActionOutputs {\n  describeType: Promise<ModuleTypeDescription>\n  validate: Promise<ValidateModuleResult>\n  getBuildStatus: Promise<BuildStatus>\n  build: Promise<BuildResult>\n  pushModule: Promise<PushResult>\n  publishModule: Promise<PublishResult>\n  runModule: Promise<RunResult>\n  testModule: Promise<TestResult>\n  getTestResult: Promise<TestResult | null>\n}\n"]} diff --git a/garden-service/build/types/plugin/params.d.ts b/garden-service/build/types/plugin/params.d.ts new file mode 100644 index 00000000000..b8d3c0b9c8d --- /dev/null +++ b/garden-service/build/types/plugin/params.d.ts @@ -0,0 +1,160 @@ +import Stream from "ts-stream"; +import { LogEntry } from "../../logger/log-entry"; +import { PluginContext } from "../../plugin-context"; +import { ModuleVersion } from "../../vcs/base"; +import { Primitive } from "../../config/common"; +import { Module } from "../module"; +import { RuntimeContext, Service } from "../service"; +import { EnvironmentStatus, ServiceLogEntry } from "./outputs"; +import * as Joi from "joi"; +export interface PluginActionContextParams { + ctx: PluginContext; +} +export interface PluginActionParamsBase extends PluginActionContextParams { + logEntry?: LogEntry; +} +export interface PluginModuleActionParamsBase extends PluginActionParamsBase { + module: T; +} +export interface PluginServiceActionParamsBase extends PluginModuleActionParamsBase { + runtimeContext?: RuntimeContext; + service: Service; +} +/** + * Plugin actions + */ +export interface DescribeModuleTypeParams { +} +export declare const describeModuleTypeParamsSchema: Joi.ObjectSchema; +export interface ValidateModuleParams { + ctx: PluginContext; + logEntry?: LogEntry; + moduleConfig: T["_ConfigType"]; +} +export declare const validateModuleParamsSchema: Joi.ObjectSchema; +export interface GetEnvironmentStatusParams extends PluginActionParamsBase { +} +export declare const getEnvironmentStatusParamsSchema: Joi.ObjectSchema; +export interface PrepareEnvironmentParams extends PluginActionParamsBase { + status: EnvironmentStatus; + force: boolean; +} +export declare const prepareEnvironmentParamsSchema: Joi.ObjectSchema; +export interface CleanupEnvironmentParams extends PluginActionParamsBase { +} +export declare const cleanupEnvironmentParamsSchema: Joi.ObjectSchema; +export interface GetSecretParams extends PluginActionParamsBase { + key: string; +} +export declare const getSecretParamsSchema: Joi.ObjectSchema; +export interface SetSecretParams extends PluginActionParamsBase { + key: string; + value: Primitive; +} +export declare const setSecretParamsSchema: Joi.ObjectSchema; +export interface DeleteSecretParams extends PluginActionParamsBase { + key: string; +} +export declare const deleteSecretParamsSchema: Joi.ObjectSchema; +export interface PluginActionParams { + getEnvironmentStatus: GetEnvironmentStatusParams; + prepareEnvironment: PrepareEnvironmentParams; + cleanupEnvironment: CleanupEnvironmentParams; + getSecret: GetSecretParams; + setSecret: SetSecretParams; + deleteSecret: DeleteSecretParams; +} +/** + * Module actions + */ +export interface GetBuildStatusParams extends PluginModuleActionParamsBase { +} +export declare const getBuildStatusParamsSchema: Joi.ObjectSchema; +export interface BuildModuleParams extends PluginModuleActionParamsBase { +} +export declare const buildModuleParamsSchema: Joi.ObjectSchema; +export interface PushModuleParams extends PluginModuleActionParamsBase { +} +export declare const pushModuleParamsSchema: Joi.ObjectSchema; +export interface PublishModuleParams extends PluginModuleActionParamsBase { +} +export declare const publishModuleParamsSchema: Joi.ObjectSchema; +export interface RunModuleParams extends PluginModuleActionParamsBase { + command: string[]; + interactive: boolean; + runtimeContext: RuntimeContext; + silent: boolean; + timeout?: number; +} +export declare const runModuleParamsSchema: Joi.ObjectSchema; +export interface TestModuleParams extends PluginModuleActionParamsBase { + interactive: boolean; + runtimeContext: RuntimeContext; + silent: boolean; + testConfig: T["testConfigs"][0]; +} +export declare const testModuleParamsSchema: Joi.ObjectSchema; +export interface GetTestResultParams extends PluginModuleActionParamsBase { + testName: string; + version: ModuleVersion; +} +export declare const getTestResultParamsSchema: Joi.ObjectSchema; +/** + * Service actions + */ +export interface GetServiceStatusParams extends PluginServiceActionParamsBase { + runtimeContext: RuntimeContext; +} +export declare const getServiceStatusParamsSchema: Joi.ObjectSchema; +export interface DeployServiceParams extends PluginServiceActionParamsBase { + force: boolean; + runtimeContext: RuntimeContext; +} +export declare const deployServiceParamsSchema: Joi.ObjectSchema; +export interface DeleteServiceParams extends PluginServiceActionParamsBase { + runtimeContext: RuntimeContext; +} +export declare const deleteServiceParamsSchema: Joi.ObjectSchema; +export interface GetServiceOutputsParams extends PluginServiceActionParamsBase { +} +export declare const getServiceOutputsParamsSchema: Joi.ObjectSchema; +export interface ExecInServiceParams extends PluginServiceActionParamsBase { + command: string[]; + runtimeContext: RuntimeContext; +} +export declare const execInServiceParamsSchema: Joi.ObjectSchema; +export interface GetServiceLogsParams extends PluginServiceActionParamsBase { + runtimeContext: RuntimeContext; + stream: Stream; + tail: boolean; + startTime?: Date; +} +export declare const getServiceLogsParamsSchema: Joi.ObjectSchema; +export interface RunServiceParams extends PluginServiceActionParamsBase { + interactive: boolean; + runtimeContext: RuntimeContext; + silent: boolean; + timeout?: number; +} +export declare const runServiceParamsSchema: Joi.ObjectSchema; +export interface ServiceActionParams { + getServiceStatus: GetServiceStatusParams; + deployService: DeployServiceParams; + deleteService: DeleteServiceParams; + getServiceOutputs: GetServiceOutputsParams; + execInService: ExecInServiceParams; + getServiceLogs: GetServiceLogsParams; + runService: RunServiceParams; +} +export interface ModuleActionParams { + describeType: DescribeModuleTypeParams; + validate: ValidateModuleParams; + getBuildStatus: GetBuildStatusParams; + build: BuildModuleParams; + pushModule: PushModuleParams; + publishModule: PublishModuleParams; + runModule: RunModuleParams; + testModule: TestModuleParams; + getTestResult: GetTestResultParams; +} +//# sourceMappingURL=params.d.ts.map \ No newline at end of file diff --git a/garden-service/build/types/plugin/params.js b/garden-service/build/types/plugin/params.js new file mode 100644 index 00000000000..c5f5184e8a5 --- /dev/null +++ b/garden-service/build/types/plugin/params.js @@ -0,0 +1,133 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const plugin_context_1 = require("../../plugin-context"); +const base_1 = require("../../vcs/base"); +const common_1 = require("../../config/common"); +const module_1 = require("../module"); +const service_1 = require("../service"); +const outputs_1 = require("./outputs"); +const Joi = require("joi"); +const module_2 = require("../../config/module"); +const test_1 = require("../../config/test"); +// Note: not specifying this further because we will later remove it from the API +const logEntrySchema = Joi.object() + .description("Logging context handler that the handler can use to log messages and progress."); +const actionParamsSchema = Joi.object() + .keys({ + ctx: plugin_context_1.pluginContextSchema + .required(), + logEntry: logEntrySchema, +}); +const moduleActionParamsSchema = actionParamsSchema + .keys({ + module: module_1.moduleSchema, +}); +const serviceActionParamsSchema = moduleActionParamsSchema + .keys({ + runtimeContext: service_1.runtimeContextSchema + .optional(), + service: service_1.serviceSchema, +}); +exports.describeModuleTypeParamsSchema = Joi.object() + .keys({}); +exports.validateModuleParamsSchema = Joi.object() + .keys({ + ctx: plugin_context_1.pluginContextSchema + .required(), + logEntry: logEntrySchema, + moduleConfig: module_2.moduleConfigSchema + .required(), +}); +exports.getEnvironmentStatusParamsSchema = actionParamsSchema; +exports.prepareEnvironmentParamsSchema = actionParamsSchema + .keys({ + status: outputs_1.environmentStatusSchema, + force: Joi.boolean() + .description("Force re-configuration of the environment."), +}); +exports.cleanupEnvironmentParamsSchema = actionParamsSchema; +exports.getSecretParamsSchema = actionParamsSchema + .keys({ + key: Joi.string() + .description("A unique identifier for the secret."), +}); +exports.setSecretParamsSchema = exports.getSecretParamsSchema + .keys({ + value: common_1.joiPrimitive() + .description("The value of the secret."), +}); +exports.deleteSecretParamsSchema = exports.getSecretParamsSchema; +exports.getBuildStatusParamsSchema = moduleActionParamsSchema; +exports.buildModuleParamsSchema = moduleActionParamsSchema; +exports.pushModuleParamsSchema = moduleActionParamsSchema; +exports.publishModuleParamsSchema = moduleActionParamsSchema; +const runBaseParams = { + interactive: Joi.boolean() + .description("Whether to run the module interactively (i.e. attach to the terminal)."), + runtimeContext: service_1.runtimeContextSchema, + silent: Joi.boolean() + .description("Set to false if the output should not be logged to the console."), + timeout: Joi.number() + .optional() + .description("If set, how long to run the command before timing out."), +}; +const runModuleBaseSchema = moduleActionParamsSchema + .keys(runBaseParams); +exports.runModuleParamsSchema = runModuleBaseSchema + .keys({ + command: common_1.joiArray(Joi.string()) + .description("The command to run in the module."), +}); +exports.testModuleParamsSchema = runModuleBaseSchema + .keys({ + testConfig: test_1.testConfigSchema, +}); +exports.getTestResultParamsSchema = moduleActionParamsSchema + .keys({ + testName: Joi.string() + .description("A unique name to identify the test run."), + version: base_1.moduleVersionSchema, +}); +exports.getServiceStatusParamsSchema = serviceActionParamsSchema + .keys({ + runtimeContext: service_1.runtimeContextSchema, +}); +exports.deployServiceParamsSchema = serviceActionParamsSchema + .keys({ + force: Joi.boolean() + .description("Whether to force a re-deploy, even if the service is already deployed."), + runtimeContext: service_1.runtimeContextSchema, +}); +exports.deleteServiceParamsSchema = serviceActionParamsSchema + .keys({ + runtimeContext: service_1.runtimeContextSchema, +}); +exports.getServiceOutputsParamsSchema = serviceActionParamsSchema; +exports.execInServiceParamsSchema = serviceActionParamsSchema + .keys({ + command: common_1.joiArray(Joi.string()) + .description("The command to run alongside the service."), + runtimeContext: service_1.runtimeContextSchema, +}); +exports.getServiceLogsParamsSchema = serviceActionParamsSchema + .keys({ + runtimeContext: service_1.runtimeContextSchema, + stream: Joi.object() + .description("A Stream object, to write the logs to."), + tail: Joi.boolean() + .description("Whether to keep listening for logs until aborted."), + startTime: Joi.date() + .optional() + .description("If set, only return logs that are as new or newer than this date."), +}); +exports.runServiceParamsSchema = serviceActionParamsSchema + .keys(runBaseParams); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["types/plugin/params.ts"],"names":[],"mappings":"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","file":"types/plugin/params.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport Stream from \"ts-stream\"\nimport { LogEntry } from \"../../logger/log-entry\"\nimport { PluginContext, pluginContextSchema } from \"../../plugin-context\"\nimport { ModuleVersion, moduleVersionSchema } from \"../../vcs/base\"\nimport { Primitive, joiPrimitive, joiArray } from \"../../config/common\"\nimport { Module, moduleSchema } from \"../module\"\nimport { RuntimeContext, Service, serviceSchema, runtimeContextSchema } from \"../service\"\nimport { EnvironmentStatus, ServiceLogEntry, environmentStatusSchema } from \"./outputs\"\nimport * as Joi from \"joi\"\nimport { moduleConfigSchema } from \"../../config/module\"\nimport { testConfigSchema } from \"../../config/test\"\n\nexport interface PluginActionContextParams {\n  ctx: PluginContext\n}\n\nexport interface PluginActionParamsBase extends PluginActionContextParams {\n  logEntry?: LogEntry\n}\n\n// Note: not specifying this further because we will later remove it from the API\nconst logEntrySchema = Joi.object()\n  .description(\"Logging context handler that the handler can use to log messages and progress.\")\n\nconst actionParamsSchema = Joi.object()\n  .keys({\n    ctx: pluginContextSchema\n      .required(),\n    logEntry: logEntrySchema,\n  })\n\nexport interface PluginModuleActionParamsBase<T extends Module = Module> extends PluginActionParamsBase {\n  module: T\n}\nconst moduleActionParamsSchema = actionParamsSchema\n  .keys({\n    module: moduleSchema,\n  })\n\nexport interface PluginServiceActionParamsBase<T extends Module = Module> extends PluginModuleActionParamsBase<T> {\n  runtimeContext?: RuntimeContext\n  service: Service<T>\n}\nconst serviceActionParamsSchema = moduleActionParamsSchema\n  .keys({\n    runtimeContext: runtimeContextSchema\n      .optional(),\n    service: serviceSchema,\n  })\n\n/**\n * Plugin actions\n */\nexport interface DescribeModuleTypeParams { }\nexport const describeModuleTypeParamsSchema = Joi.object()\n  .keys({})\n\nexport interface ValidateModuleParams<T extends Module = Module> {\n  ctx: PluginContext\n  logEntry?: LogEntry\n  moduleConfig: T[\"_ConfigType\"]\n}\nexport const validateModuleParamsSchema = Joi.object()\n  .keys({\n    ctx: pluginContextSchema\n      .required(),\n    logEntry: logEntrySchema,\n    moduleConfig: moduleConfigSchema\n      .required(),\n  })\n\nexport interface GetEnvironmentStatusParams extends PluginActionParamsBase { }\nexport const getEnvironmentStatusParamsSchema = actionParamsSchema\n\nexport interface PrepareEnvironmentParams extends PluginActionParamsBase {\n  status: EnvironmentStatus\n  force: boolean\n}\nexport const prepareEnvironmentParamsSchema = actionParamsSchema\n  .keys({\n    status: environmentStatusSchema,\n    force: Joi.boolean()\n      .description(\"Force re-configuration of the environment.\"),\n  })\n\nexport interface CleanupEnvironmentParams extends PluginActionParamsBase {\n}\nexport const cleanupEnvironmentParamsSchema = actionParamsSchema\n\nexport interface GetSecretParams extends PluginActionParamsBase {\n  key: string\n}\nexport const getSecretParamsSchema = actionParamsSchema\n  .keys({\n    key: Joi.string()\n      .description(\"A unique identifier for the secret.\"),\n  })\n\nexport interface SetSecretParams extends PluginActionParamsBase {\n  key: string\n  value: Primitive\n}\nexport const setSecretParamsSchema = getSecretParamsSchema\n  .keys({\n    value: joiPrimitive()\n      .description(\"The value of the secret.\"),\n  })\n\nexport interface DeleteSecretParams extends PluginActionParamsBase {\n  key: string\n}\nexport const deleteSecretParamsSchema = getSecretParamsSchema\n\nexport interface PluginActionParams {\n  getEnvironmentStatus: GetEnvironmentStatusParams\n  prepareEnvironment: PrepareEnvironmentParams\n  cleanupEnvironment: CleanupEnvironmentParams\n\n  getSecret: GetSecretParams\n  setSecret: SetSecretParams\n  deleteSecret: DeleteSecretParams\n}\n\n/**\n * Module actions\n */\nexport interface GetBuildStatusParams<T extends Module = Module> extends PluginModuleActionParamsBase<T> { }\nexport const getBuildStatusParamsSchema = moduleActionParamsSchema\n\nexport interface BuildModuleParams<T extends Module = Module> extends PluginModuleActionParamsBase<T> { }\nexport const buildModuleParamsSchema = moduleActionParamsSchema\n\nexport interface PushModuleParams<T extends Module = Module> extends PluginModuleActionParamsBase<T> { }\nexport const pushModuleParamsSchema = moduleActionParamsSchema\n\nexport interface PublishModuleParams<T extends Module = Module> extends PluginModuleActionParamsBase<T> { }\nexport const publishModuleParamsSchema = moduleActionParamsSchema\n\nexport interface RunModuleParams<T extends Module = Module> extends PluginModuleActionParamsBase<T> {\n  command: string[]\n  interactive: boolean\n  runtimeContext: RuntimeContext\n  silent: boolean\n  timeout?: number\n}\nconst runBaseParams = {\n  interactive: Joi.boolean()\n    .description(\"Whether to run the module interactively (i.e. attach to the terminal).\"),\n  runtimeContext: runtimeContextSchema,\n  silent: Joi.boolean()\n    .description(\"Set to false if the output should not be logged to the console.\"),\n  timeout: Joi.number()\n    .optional()\n    .description(\"If set, how long to run the command before timing out.\"),\n}\nconst runModuleBaseSchema = moduleActionParamsSchema\n  .keys(runBaseParams)\nexport const runModuleParamsSchema = runModuleBaseSchema\n  .keys({\n    command: joiArray(Joi.string())\n      .description(\"The command to run in the module.\"),\n  })\n\nexport interface TestModuleParams<T extends Module = Module> extends PluginModuleActionParamsBase<T> {\n  interactive: boolean\n  runtimeContext: RuntimeContext\n  silent: boolean\n  testConfig: T[\"testConfigs\"][0]\n}\nexport const testModuleParamsSchema = runModuleBaseSchema\n  .keys({\n    testConfig: testConfigSchema,\n  })\n\nexport interface GetTestResultParams<T extends Module = Module> extends PluginModuleActionParamsBase<T> {\n  testName: string\n  version: ModuleVersion\n}\nexport const getTestResultParamsSchema = moduleActionParamsSchema\n  .keys({\n    testName: Joi.string()\n      .description(\"A unique name to identify the test run.\"),\n    version: moduleVersionSchema,\n  })\n\n/**\n * Service actions\n */\nexport interface GetServiceStatusParams<T extends Module = Module> extends PluginServiceActionParamsBase<T> {\n  runtimeContext: RuntimeContext\n}\nexport const getServiceStatusParamsSchema = serviceActionParamsSchema\n  .keys({\n    runtimeContext: runtimeContextSchema,\n  })\n\nexport interface DeployServiceParams<T extends Module = Module> extends PluginServiceActionParamsBase<T> {\n  force: boolean\n  runtimeContext: RuntimeContext\n}\nexport const deployServiceParamsSchema = serviceActionParamsSchema\n  .keys({\n    force: Joi.boolean()\n      .description(\"Whether to force a re-deploy, even if the service is already deployed.\"),\n    runtimeContext: runtimeContextSchema,\n  })\n\nexport interface DeleteServiceParams<T extends Module = Module> extends PluginServiceActionParamsBase<T> {\n  runtimeContext: RuntimeContext\n}\nexport const deleteServiceParamsSchema = serviceActionParamsSchema\n  .keys({\n    runtimeContext: runtimeContextSchema,\n  })\n\nexport interface GetServiceOutputsParams<T extends Module = Module> extends PluginServiceActionParamsBase<T> { }\nexport const getServiceOutputsParamsSchema = serviceActionParamsSchema\n\nexport interface ExecInServiceParams<T extends Module = Module> extends PluginServiceActionParamsBase<T> {\n  command: string[]\n  runtimeContext: RuntimeContext\n}\nexport const execInServiceParamsSchema = serviceActionParamsSchema\n  .keys({\n    command: joiArray(Joi.string())\n      .description(\"The command to run alongside the service.\"),\n    runtimeContext: runtimeContextSchema,\n  })\n\nexport interface GetServiceLogsParams<T extends Module = Module> extends PluginServiceActionParamsBase<T> {\n  runtimeContext: RuntimeContext\n  stream: Stream<ServiceLogEntry>\n  tail: boolean\n  startTime?: Date\n}\nexport const getServiceLogsParamsSchema = serviceActionParamsSchema\n  .keys({\n    runtimeContext: runtimeContextSchema,\n    stream: Joi.object()\n      .description(\"A Stream object, to write the logs to.\"),\n    tail: Joi.boolean()\n      .description(\"Whether to keep listening for logs until aborted.\"),\n    startTime: Joi.date()\n      .optional()\n      .description(\"If set, only return logs that are as new or newer than this date.\"),\n  })\n\nexport interface RunServiceParams<T extends Module = Module> extends PluginServiceActionParamsBase<T> {\n  interactive: boolean\n  runtimeContext: RuntimeContext\n  silent: boolean\n  timeout?: number\n}\nexport const runServiceParamsSchema = serviceActionParamsSchema\n  .keys(runBaseParams)\n\nexport interface ServiceActionParams<T extends Module = Module> {\n  getServiceStatus: GetServiceStatusParams<T>\n  deployService: DeployServiceParams<T>\n  deleteService: DeleteServiceParams<T>\n  getServiceOutputs: GetServiceOutputsParams<T>\n  execInService: ExecInServiceParams<T>\n  getServiceLogs: GetServiceLogsParams<T>\n  runService: RunServiceParams<T>\n}\n\nexport interface ModuleActionParams<T extends Module = Module> {\n  describeType: DescribeModuleTypeParams,\n  validate: ValidateModuleParams<T>\n  getBuildStatus: GetBuildStatusParams<T>\n  build: BuildModuleParams<T>\n  pushModule: PushModuleParams<T>\n  publishModule: PublishModuleParams<T>\n  runModule: RunModuleParams<T>\n  testModule: TestModuleParams<T>\n  getTestResult: GetTestResultParams<T>\n}\n"]} diff --git a/garden-service/build/types/plugin/plugin.d.ts b/garden-service/build/types/plugin/plugin.d.ts new file mode 100644 index 00000000000..3ba3811009b --- /dev/null +++ b/garden-service/build/types/plugin/plugin.d.ts @@ -0,0 +1,60 @@ +import * as Joi from "joi"; +import { Module } from "../module"; +import { LogNode } from "../../logger/log-node"; +import { Provider } from "../../config/project"; +import { ModuleActionOutputs, PluginActionOutputs, ServiceActionOutputs } from "./outputs"; +import { ModuleActionParams, PluginActionParams, ServiceActionParams } from "./params"; +export declare type PluginActions = { + [P in keyof PluginActionParams]: (params: PluginActionParams[P]) => PluginActionOutputs[P]; +}; +export declare type ServiceActions = { + [P in keyof ServiceActionParams]: (params: ServiceActionParams[P]) => ServiceActionOutputs[P]; +}; +export declare type ModuleActions = { + [P in keyof ModuleActionParams]: (params: ModuleActionParams[P]) => ModuleActionOutputs[P]; +}; +export declare type ModuleAndServiceActions = ModuleActions & ServiceActions; +export declare type PluginActionName = keyof PluginActions; +export declare type ServiceActionName = keyof ServiceActions; +export declare type ModuleActionName = keyof ModuleActions; +export interface PluginActionDescription { + description: string; + paramsSchema: Joi.Schema; + resultSchema: Joi.Schema; +} +export declare const pluginActionDescriptions: { + [P in PluginActionName]: PluginActionDescription; +}; +export declare const serviceActionDescriptions: { + [P in ServiceActionName]: PluginActionDescription; +}; +export declare const moduleActionDescriptions: { + [P in ModuleActionName | ServiceActionName]: PluginActionDescription; +}; +export declare const pluginActionNames: PluginActionName[]; +export declare const serviceActionNames: ServiceActionName[]; +export declare const moduleActionNames: ModuleActionName[]; +export interface GardenPlugin { + config?: object; + configKeys?: string[]; + modules?: string[]; + actions?: Partial; + moduleActions?: { + [moduleType: string]: Partial; + }; +} +export interface PluginFactoryParams { + config: T["config"]; + logEntry: LogNode; + projectName: string; +} +export interface PluginFactory { + (params: PluginFactoryParams): GardenPlugin | Promise; +} +export declare type RegisterPluginParam = string | PluginFactory; +export interface Plugins { + [name: string]: RegisterPluginParam; +} +export declare const pluginSchema: Joi.ObjectSchema; +export declare const pluginModuleSchema: Joi.ObjectSchema; +//# sourceMappingURL=plugin.d.ts.map \ No newline at end of file diff --git a/garden-service/build/types/plugin/plugin.js b/garden-service/build/types/plugin/plugin.js new file mode 100644 index 00000000000..e6d5f3a3fae --- /dev/null +++ b/garden-service/build/types/plugin/plugin.js @@ -0,0 +1,293 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const lodash_1 = require("lodash"); +const dedent = require("dedent"); +const common_1 = require("../../config/common"); +const service_1 = require("../service"); +const service_2 = require("../../config/service"); +const params_1 = require("./params"); +const outputs_1 = require("./outputs"); +const params_2 = require("./params"); +exports.pluginActionDescriptions = { + getEnvironmentStatus: { + description: dedent ` + Check if the current environment is ready for use by this plugin. Use this action in combination + with \`prepareEnvironment\`. + + Called before \`prepareEnvironment\`. If this returns \`ready: true\`, the + \`prepareEnvironment\` action is not called. + + If this returns \`needUserInput: true\`, the process may throw an error and guide the user to + run \`garden init\`, so that \`prepareEnvironment\` can safely ask for user input. Otherwise the + \`prepareEnvironment\` handler may be run implicitly ahead of actions like \`deployService\`, + \`runModule\` etc. + `, + paramsSchema: params_2.getEnvironmentStatusParamsSchema, + resultSchema: outputs_1.environmentStatusSchema, + }, + prepareEnvironment: { + description: dedent ` + Make sure the environment is set up for this plugin. Use this action to do any bootstrapping required + before deploying services. + + Called ahead of any service runtime actions (such as \`deployService\`, + \`runModule\` and \`testModule\`), unless \`getEnvironmentStatus\` returns \`ready: true\` or + \`needUserInput: true\`. + + Important: If your handler does require user input, please be sure to indicate that via the + \`getEnvironmentStatus\` handler. If this provider's \`getEnvironmentStatus\` returns \`needUserInput: true\`, + this is only called via the \`garden init\` command, so that the handler can safely request user input via + the CLI. + `, + paramsSchema: params_1.prepareEnvironmentParamsSchema, + resultSchema: outputs_1.prepareEnvironmentResultSchema, + }, + cleanupEnvironment: { + description: dedent ` + Clean up any runtime components, services etc. that this plugin has deployed in the environment. + + Like \`prepareEnvironment\`, this is executed sequentially, so handlers are allowed to request user input + if necessary. + + Called by the \`garden delete environment\` command. + `, + paramsSchema: params_1.cleanupEnvironmentParamsSchema, + resultSchema: outputs_1.cleanupEnvironmentResultSchema, + }, + getSecret: { + description: dedent ` + Retrieve a secret value for this plugin in the current environment (as set via \`setSecret\`). + `, + paramsSchema: params_1.getSecretParamsSchema, + resultSchema: outputs_1.getSecretResultSchema, + }, + setSecret: { + description: dedent ` + Set a secret for this plugin in the current environment. These variables are + not used by the Garden framework, but the plugin may expose them to services etc. at runtime + (e.g. as environment variables or mounted in containers). + `, + paramsSchema: params_1.setSecretParamsSchema, + resultSchema: outputs_1.setSecretResultSchema, + }, + deleteSecret: { + description: dedent ` + Remove a secret for this plugin in the current environment (as set via \`setSecret\`). + `, + paramsSchema: params_1.deleteSecretParamsSchema, + resultSchema: outputs_1.deleteSecretResultSchema, + }, +}; +exports.serviceActionDescriptions = { + getServiceStatus: { + description: dedent ` + Check and return the current runtime status of a service. + + Called ahead of any actions that expect a service to be running, as well as the + \`garden get status\` command. + `, + paramsSchema: params_1.getServiceStatusParamsSchema, + resultSchema: service_1.serviceStatusSchema, + }, + deployService: { + description: dedent ` + Deploy the specified service. This should wait until the service is ready and accessible, + and fail if the service doesn't reach a ready state. + + Called by the \`garden deploy\` and \`garden dev\` commands. + `, + paramsSchema: params_1.deployServiceParamsSchema, + resultSchema: service_1.serviceStatusSchema, + }, + deleteService: { + description: dedent ` + Terminate a deployed service. This should wait until the service is no longer running. + + Called by the \`garden delete service\` command. + `, + paramsSchema: params_1.deleteServiceParamsSchema, + resultSchema: service_1.serviceStatusSchema, + }, + getServiceOutputs: { + description: "DEPRECATED", + paramsSchema: params_1.getServiceOutputsParamsSchema, + resultSchema: service_2.serviceOutputsSchema, + }, + execInService: { + description: dedent ` + Execute the specified command next to a running service, e.g. in a service container. + + Called by the \`garden exec\` command. + `, + paramsSchema: params_1.execInServiceParamsSchema, + resultSchema: outputs_1.execInServiceResultSchema, + }, + getServiceLogs: { + description: dedent ` + Retrieve a stream of logs for the specified service, optionally waiting listening for new logs. + + Called by the \`garden logs\` command. + `, + paramsSchema: params_1.getServiceLogsParamsSchema, + resultSchema: outputs_1.getServiceLogsResultSchema, + }, + runService: { + description: dedent ` + Run an ad-hoc instance of the specified service. This should wait until the service completes + execution, and should ideally attach it to the terminal (i.e. pipe the output from the service + to the console, as well as pipe the input from the console to the running service). + + Called by the \`garden run service\` command. + `, + paramsSchema: params_1.runServiceParamsSchema, + resultSchema: outputs_1.runResultSchema, + }, +}; +exports.moduleActionDescriptions = Object.assign({ + // TODO: implement this method (it is currently not defined or used) + describeType: { + description: dedent ` + Return documentation and a schema description of the module type. + + The documentation should be in markdown format. A reference for the module type is automatically + generated based on the provided schema, and a section appended to the provided documentation. + + The schema should be a valid OpenAPI schema describing the configuration keys that the user + should use under the \`module\` key in a \`garden.yml\` configuration file. Note that the schema + should not specify the built-in fields (such as \`name\`, \`type\` and \`description\`). + + Used when auto-generating framework documentation. + `, + paramsSchema: params_1.describeModuleTypeParamsSchema, + resultSchema: outputs_1.moduleTypeDescriptionSchema, + }, validate: { + description: dedent ` + Validate and optionally transform the given module configuration. + + Note that this does not need to perform structural schema validation (the framework does that + automatically), but should in turn perform semantic validation to make sure the configuration is sane. + + This can and should also be used to further specify the semantics of the module, including service + configuration and test configuration. Since services and tests are not specified using built-in + framework configuration fields, this action needs to specify those via the \`serviceConfigs\` and + \`testConfigs\` output keys. + `, + paramsSchema: params_1.validateModuleParamsSchema, + resultSchema: outputs_1.validateModuleResultSchema, + }, getBuildStatus: { + description: dedent ` + Check and return the build status of a module, i.e. whether the current version been built. + + Called before running the \`build\` action, which is not run if this returns \`{ ready: true }\`. + `, + paramsSchema: params_1.getBuildStatusParamsSchema, + resultSchema: outputs_1.buildStatusSchema, + }, build: { + description: dedent ` + Build the current version of a module. This must wait until the build is complete before returning. + + Called ahead of a number of actions, including \`deployService\`, \`pushModule\` and \`publishModule\`. + `, + paramsSchema: params_1.buildModuleParamsSchema, + resultSchema: outputs_1.buildModuleResultSchema, + }, pushModule: { + description: dedent ` + Push the build for current version of a module to the deployment environment, making it accessible + to the development environment. An example being a container registry or artifact registry that's + available to the deployment environment when deploying. + + Note the distinction to \`publishModule\` which may, depending on the module type, work similarly but + is only called when explicitly calling the \`garden publish\`. + + This is usually not necessary for plugins that run locally. + + Called before the \`deployService\` action. + `, + paramsSchema: params_1.pushModuleParamsSchema, + resultSchema: outputs_1.pushModuleResultSchema, + }, publishModule: { + description: dedent ` + Publish a built module to a remote registry. + + Note the distinction to \`pushModule\` which may, depending on the module type, work similarly but + is automatically called ahead of \`deployService\`. + + Called by the \`garden publish\` command. + `, + paramsSchema: params_1.publishModuleParamsSchema, + resultSchema: outputs_1.publishModuleResultSchema, + }, runModule: { + description: dedent ` + Run an ad-hoc instance of the specified module. This should wait until the execution completes, + and should ideally attach it to the terminal (i.e. pipe the output from the service + to the console, as well as pipe the input from the console to the running service). + + Called by the \`garden run module\` command. + `, + paramsSchema: params_1.runModuleParamsSchema, + resultSchema: outputs_1.runResultSchema, + }, testModule: { + description: dedent ` + Run the specified test for a module. + + This should complete the test run and return the logs from the test run, and signal whether the + tests completed successfully. + + It should also store the test results and provide the accompanying \`getTestResult\` handler, + so that the same version does not need to be tested multiple times. + + Note that the version string provided to this handler may be a hash of the module's version, as + well as any runtime dependencies configured for the test, so it may not match the current version + of the module itself. + `, + paramsSchema: params_1.testModuleParamsSchema, + resultSchema: outputs_1.testResultSchema, + }, getTestResult: { + description: dedent ` + Retrieve the test result for the specified version. Use this along with the \`testModule\` handler + to avoid testing the same code repeatedly. + + Note that the version string provided to this handler may be a hash of the module's version, as + well as any runtime dependencies configured for the test, so it may not match the current version + of the module itself. + `, + paramsSchema: params_1.getTestResultParamsSchema, + resultSchema: outputs_1.getTestResultSchema, + } }, exports.serviceActionDescriptions); +exports.pluginActionNames = Object.keys(exports.pluginActionDescriptions); +exports.serviceActionNames = Object.keys(exports.serviceActionDescriptions); +exports.moduleActionNames = Object.keys(exports.moduleActionDescriptions); +exports.pluginSchema = Joi.object() + .keys({ + config: Joi.object() + .meta({ extendable: true }) + .description("Plugins may use this key to override or augment their configuration " + + "(as specified in the garden.yml provider configuration."), + modules: common_1.joiArray(Joi.string()) + .description("Plugins may optionally provide paths to Garden modules that are loaded as part of the plugin. " + + "This is useful, for example, to provide build dependencies for other modules " + + "or as part of the plugin operation."), + // TODO: document plugin actions further + actions: Joi.object().keys(lodash_1.mapValues(exports.pluginActionDescriptions, () => Joi.func())) + .description("A map of plugin action handlers provided by the plugin."), + moduleActions: common_1.joiIdentifierMap(Joi.object().keys(lodash_1.mapValues(exports.moduleActionDescriptions, () => Joi.func())).description("A map of module names and module action handlers provided by the plugin.")), +}) + .description("The schema for Garden plugins."); +exports.pluginModuleSchema = Joi.object() + .keys({ + name: common_1.joiIdentifier(), + gardenPlugin: Joi.func().required() + .description("The initialization function for the plugin. Should return a valid Garden plugin object."), +}) + .unknown(true) + .description("A module containing a Garden plugin."); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["types/plugin/plugin.ts"],"names":[],"mappings":"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","file":"types/plugin/plugin.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Joi from \"joi\"\nimport { mapValues } from \"lodash\"\nimport dedent = require(\"dedent\")\nimport {\n  joiArray,\n  joiIdentifier,\n  joiIdentifierMap,\n} from \"../../config/common\"\nimport { Module } from \"../module\"\nimport { serviceStatusSchema } from \"../service\"\nimport { serviceOutputsSchema } from \"../../config/service\"\nimport { LogNode } from \"../../logger/log-node\"\nimport { Provider } from \"../../config/project\"\nimport {\n  prepareEnvironmentParamsSchema,\n  cleanupEnvironmentParamsSchema,\n  getSecretParamsSchema,\n  setSecretParamsSchema,\n  deleteSecretParamsSchema,\n  getServiceStatusParamsSchema,\n  deployServiceParamsSchema,\n  deleteServiceParamsSchema,\n  getServiceOutputsParamsSchema,\n  execInServiceParamsSchema,\n  getServiceLogsParamsSchema,\n  runServiceParamsSchema,\n  describeModuleTypeParamsSchema,\n  validateModuleParamsSchema,\n  getBuildStatusParamsSchema,\n  buildModuleParamsSchema,\n  pushModuleParamsSchema,\n  runModuleParamsSchema,\n  testModuleParamsSchema,\n  getTestResultParamsSchema,\n  publishModuleParamsSchema,\n} from \"./params\"\nimport {\n  buildModuleResultSchema,\n  buildStatusSchema,\n  prepareEnvironmentResultSchema,\n  deleteSecretResultSchema,\n  cleanupEnvironmentResultSchema,\n  environmentStatusSchema,\n  execInServiceResultSchema,\n  getSecretResultSchema,\n  getServiceLogsResultSchema,\n  getTestResultSchema,\n  ModuleActionOutputs,\n  moduleTypeDescriptionSchema,\n  PluginActionOutputs,\n  pushModuleResultSchema,\n  runResultSchema,\n  ServiceActionOutputs,\n  setSecretResultSchema,\n  testResultSchema,\n  validateModuleResultSchema,\n  publishModuleResultSchema,\n} from \"./outputs\"\nimport {\n  ModuleActionParams,\n  PluginActionParams,\n  ServiceActionParams,\n  getEnvironmentStatusParamsSchema,\n} from \"./params\"\n\nexport type PluginActions = {\n  [P in keyof PluginActionParams]: (params: PluginActionParams[P]) => PluginActionOutputs[P]\n}\n\nexport type ServiceActions<T extends Module = Module> = {\n  [P in keyof ServiceActionParams<T>]: (params: ServiceActionParams<T>[P]) => ServiceActionOutputs[P]\n}\n\nexport type ModuleActions<T extends Module = Module> = {\n  [P in keyof ModuleActionParams<T>]: (params: ModuleActionParams<T>[P]) => ModuleActionOutputs[P]\n}\n\nexport type ModuleAndServiceActions<T extends Module = Module> = ModuleActions<T> & ServiceActions<T>\n\nexport type PluginActionName = keyof PluginActions\nexport type ServiceActionName = keyof ServiceActions\nexport type ModuleActionName = keyof ModuleActions\n\nexport interface PluginActionDescription {\n  description: string\n  paramsSchema: Joi.Schema\n  resultSchema: Joi.Schema\n}\n\nexport const pluginActionDescriptions: { [P in PluginActionName]: PluginActionDescription } = {\n  getEnvironmentStatus: {\n    description: dedent`\n      Check if the current environment is ready for use by this plugin. Use this action in combination\n      with \\`prepareEnvironment\\`.\n\n      Called before \\`prepareEnvironment\\`. If this returns \\`ready: true\\`, the\n      \\`prepareEnvironment\\` action is not called.\n\n      If this returns \\`needUserInput: true\\`, the process may throw an error and guide the user to\n      run \\`garden init\\`, so that \\`prepareEnvironment\\` can safely ask for user input. Otherwise the\n      \\`prepareEnvironment\\` handler may be run implicitly ahead of actions like \\`deployService\\`,\n      \\`runModule\\` etc.\n    `,\n    paramsSchema: getEnvironmentStatusParamsSchema,\n    resultSchema: environmentStatusSchema,\n  },\n  prepareEnvironment: {\n    description: dedent`\n      Make sure the environment is set up for this plugin. Use this action to do any bootstrapping required\n      before deploying services.\n\n      Called ahead of any service runtime actions (such as \\`deployService\\`,\n      \\`runModule\\` and \\`testModule\\`), unless \\`getEnvironmentStatus\\` returns \\`ready: true\\` or\n      \\`needUserInput: true\\`.\n\n      Important: If your handler does require user input, please be sure to indicate that via the\n      \\`getEnvironmentStatus\\` handler. If this provider's \\`getEnvironmentStatus\\` returns \\`needUserInput: true\\`,\n      this is only called via the \\`garden init\\` command, so that the handler can safely request user input via\n      the CLI.\n    `,\n    paramsSchema: prepareEnvironmentParamsSchema,\n    resultSchema: prepareEnvironmentResultSchema,\n  },\n  cleanupEnvironment: {\n    description: dedent`\n      Clean up any runtime components, services etc. that this plugin has deployed in the environment.\n\n      Like \\`prepareEnvironment\\`, this is executed sequentially, so handlers are allowed to request user input\n      if necessary.\n\n      Called by the \\`garden delete environment\\` command.\n    `,\n    paramsSchema: cleanupEnvironmentParamsSchema,\n    resultSchema: cleanupEnvironmentResultSchema,\n  },\n\n  getSecret: {\n    description: dedent`\n      Retrieve a secret value for this plugin in the current environment (as set via \\`setSecret\\`).\n    `,\n    paramsSchema: getSecretParamsSchema,\n    resultSchema: getSecretResultSchema,\n  },\n  setSecret: {\n    description: dedent`\n      Set a secret for this plugin in the current environment. These variables are\n      not used by the Garden framework, but the plugin may expose them to services etc. at runtime\n      (e.g. as environment variables or mounted in containers).\n    `,\n    paramsSchema: setSecretParamsSchema,\n    resultSchema: setSecretResultSchema,\n  },\n  deleteSecret: {\n    description: dedent`\n      Remove a secret for this plugin in the current environment (as set via \\`setSecret\\`).\n    `,\n    paramsSchema: deleteSecretParamsSchema,\n    resultSchema: deleteSecretResultSchema,\n  },\n}\n\nexport const serviceActionDescriptions: { [P in ServiceActionName]: PluginActionDescription } = {\n  getServiceStatus: {\n    description: dedent`\n      Check and return the current runtime status of a service.\n\n      Called ahead of any actions that expect a service to be running, as well as the\n      \\`garden get status\\` command.\n    `,\n    paramsSchema: getServiceStatusParamsSchema,\n    resultSchema: serviceStatusSchema,\n  },\n  deployService: {\n    description: dedent`\n      Deploy the specified service. This should wait until the service is ready and accessible,\n      and fail if the service doesn't reach a ready state.\n\n      Called by the \\`garden deploy\\` and \\`garden dev\\` commands.\n    `,\n    paramsSchema: deployServiceParamsSchema,\n    resultSchema: serviceStatusSchema,\n  },\n  deleteService: {\n    description: dedent`\n      Terminate a deployed service. This should wait until the service is no longer running.\n\n      Called by the \\`garden delete service\\` command.\n    `,\n    paramsSchema: deleteServiceParamsSchema,\n    resultSchema: serviceStatusSchema,\n  },\n  getServiceOutputs: {\n    description: \"DEPRECATED\",\n    paramsSchema: getServiceOutputsParamsSchema,\n    resultSchema: serviceOutputsSchema,\n  },\n  execInService: {\n    description: dedent`\n      Execute the specified command next to a running service, e.g. in a service container.\n\n      Called by the \\`garden exec\\` command.\n    `,\n    paramsSchema: execInServiceParamsSchema,\n    resultSchema: execInServiceResultSchema,\n  },\n  getServiceLogs: {\n    description: dedent`\n      Retrieve a stream of logs for the specified service, optionally waiting listening for new logs.\n\n      Called by the \\`garden logs\\` command.\n    `,\n    paramsSchema: getServiceLogsParamsSchema,\n    resultSchema: getServiceLogsResultSchema,\n  },\n  runService: {\n    description: dedent`\n      Run an ad-hoc instance of the specified service. This should wait until the service completes\n      execution, and should ideally attach it to the terminal (i.e. pipe the output from the service\n      to the console, as well as pipe the input from the console to the running service).\n\n      Called by the \\`garden run service\\` command.\n    `,\n    paramsSchema: runServiceParamsSchema,\n    resultSchema: runResultSchema,\n  },\n}\n\nexport const moduleActionDescriptions: { [P in ModuleActionName | ServiceActionName]: PluginActionDescription } = {\n  // TODO: implement this method (it is currently not defined or used)\n  describeType: {\n    description: dedent`\n      Return documentation and a schema description of the module type.\n\n      The documentation should be in markdown format. A reference for the module type is automatically\n      generated based on the provided schema, and a section appended to the provided documentation.\n\n      The schema should be a valid OpenAPI schema describing the configuration keys that the user\n      should use under the \\`module\\` key in a \\`garden.yml\\` configuration file. Note that the schema\n      should not specify the built-in fields (such as \\`name\\`, \\`type\\` and \\`description\\`).\n\n      Used when auto-generating framework documentation.\n    `,\n    paramsSchema: describeModuleTypeParamsSchema,\n    resultSchema: moduleTypeDescriptionSchema,\n  },\n  validate: {\n    description: dedent`\n      Validate and optionally transform the given module configuration.\n\n      Note that this does not need to perform structural schema validation (the framework does that\n      automatically), but should in turn perform semantic validation to make sure the configuration is sane.\n\n      This can and should also be used to further specify the semantics of the module, including service\n      configuration and test configuration. Since services and tests are not specified using built-in\n      framework configuration fields, this action needs to specify those via the \\`serviceConfigs\\` and\n      \\`testConfigs\\` output keys.\n    `,\n    paramsSchema: validateModuleParamsSchema,\n    resultSchema: validateModuleResultSchema,\n  },\n\n  getBuildStatus: {\n    description: dedent`\n      Check and return the build status of a module, i.e. whether the current version been built.\n\n      Called before running the \\`build\\` action, which is not run if this returns \\`{ ready: true }\\`.\n    `,\n    paramsSchema: getBuildStatusParamsSchema,\n    resultSchema: buildStatusSchema,\n  },\n  build: {\n    description: dedent`\n      Build the current version of a module. This must wait until the build is complete before returning.\n\n      Called ahead of a number of actions, including \\`deployService\\`, \\`pushModule\\` and \\`publishModule\\`.\n    `,\n    paramsSchema: buildModuleParamsSchema,\n    resultSchema: buildModuleResultSchema,\n  },\n\n  pushModule: {\n    description: dedent`\n      Push the build for current version of a module to the deployment environment, making it accessible\n      to the development environment. An example being a container registry or artifact registry that's\n      available to the deployment environment when deploying.\n\n      Note the distinction to \\`publishModule\\` which may, depending on the module type, work similarly but\n      is only called when explicitly calling the \\`garden publish\\`.\n\n      This is usually not necessary for plugins that run locally.\n\n      Called before the \\`deployService\\` action.\n    `,\n    paramsSchema: pushModuleParamsSchema,\n    resultSchema: pushModuleResultSchema,\n  },\n\n  publishModule: {\n    description: dedent`\n      Publish a built module to a remote registry.\n\n      Note the distinction to \\`pushModule\\` which may, depending on the module type, work similarly but\n      is automatically called ahead of \\`deployService\\`.\n\n      Called by the \\`garden publish\\` command.\n    `,\n    paramsSchema: publishModuleParamsSchema,\n    resultSchema: publishModuleResultSchema,\n  },\n\n  runModule: {\n    description: dedent`\n      Run an ad-hoc instance of the specified module. This should wait until the execution completes,\n      and should ideally attach it to the terminal (i.e. pipe the output from the service\n      to the console, as well as pipe the input from the console to the running service).\n\n      Called by the \\`garden run module\\` command.\n    `,\n    paramsSchema: runModuleParamsSchema,\n    resultSchema: runResultSchema,\n  },\n\n  testModule: {\n    description: dedent`\n      Run the specified test for a module.\n\n      This should complete the test run and return the logs from the test run, and signal whether the\n      tests completed successfully.\n\n      It should also store the test results and provide the accompanying \\`getTestResult\\` handler,\n      so that the same version does not need to be tested multiple times.\n\n      Note that the version string provided to this handler may be a hash of the module's version, as\n      well as any runtime dependencies configured for the test, so it may not match the current version\n      of the module itself.\n    `,\n    paramsSchema: testModuleParamsSchema,\n    resultSchema: testResultSchema,\n  },\n  getTestResult: {\n    description: dedent`\n      Retrieve the test result for the specified version. Use this along with the \\`testModule\\` handler\n      to avoid testing the same code repeatedly.\n\n      Note that the version string provided to this handler may be a hash of the module's version, as\n      well as any runtime dependencies configured for the test, so it may not match the current version\n      of the module itself.\n    `,\n    paramsSchema: getTestResultParamsSchema,\n    resultSchema: getTestResultSchema,\n  },\n\n  ...serviceActionDescriptions,\n}\n\nexport const pluginActionNames: PluginActionName[] = <PluginActionName[]>Object.keys(pluginActionDescriptions)\nexport const serviceActionNames: ServiceActionName[] = <ServiceActionName[]>Object.keys(serviceActionDescriptions)\nexport const moduleActionNames: ModuleActionName[] = <ModuleActionName[]>Object.keys(moduleActionDescriptions)\n\nexport interface GardenPlugin {\n  config?: object\n  configKeys?: string[]\n\n  modules?: string[]\n\n  actions?: Partial<PluginActions>\n  moduleActions?: { [moduleType: string]: Partial<ModuleAndServiceActions> }\n}\n\nexport interface PluginFactoryParams<T extends Provider = any> {\n  config: T[\"config\"],\n  logEntry: LogNode,\n  projectName: string,\n}\n\nexport interface PluginFactory<T extends Provider = any> {\n  (params: PluginFactoryParams<T>): GardenPlugin | Promise<GardenPlugin>\n}\nexport type RegisterPluginParam = string | PluginFactory\nexport interface Plugins {\n  [name: string]: RegisterPluginParam\n}\n\nexport const pluginSchema = Joi.object()\n  .keys({\n    config: Joi.object()\n      .meta({ extendable: true })\n      .description(\n        \"Plugins may use this key to override or augment their configuration \" +\n        \"(as specified in the garden.yml provider configuration.\",\n      ),\n    modules: joiArray(Joi.string())\n      .description(\n        \"Plugins may optionally provide paths to Garden modules that are loaded as part of the plugin. \" +\n        \"This is useful, for example, to provide build dependencies for other modules \" +\n        \"or as part of the plugin operation.\",\n      ),\n    // TODO: document plugin actions further\n    actions: Joi.object().keys(mapValues(pluginActionDescriptions, () => Joi.func()))\n      .description(\"A map of plugin action handlers provided by the plugin.\"),\n    moduleActions: joiIdentifierMap(\n      Joi.object().keys(mapValues(moduleActionDescriptions, () => Joi.func()),\n      ).description(\"A map of module names and module action handlers provided by the plugin.\"),\n    ),\n  })\n  .description(\"The schema for Garden plugins.\")\n\nexport const pluginModuleSchema = Joi.object()\n  .keys({\n    name: joiIdentifier(),\n    gardenPlugin: Joi.func().required()\n      .description(\"The initialization function for the plugin. Should return a valid Garden plugin object.\"),\n  })\n  .unknown(true)\n  .description(\"A module containing a Garden plugin.\")\n"]} diff --git a/garden-service/build/types/service.d.ts b/garden-service/build/types/service.d.ts new file mode 100644 index 00000000000..ff208796676 --- /dev/null +++ b/garden-service/build/types/service.d.ts @@ -0,0 +1,54 @@ +import * as Joi from "joi"; +import { PrimitiveMap } from "../config/common"; +import { Module } from "./module"; +import { ServiceConfig } from "../config/service"; +import { Garden } from "../garden"; +export interface Service { + name: string; + module: M; + config: M["serviceConfigs"][0]; + spec: M["serviceConfigs"][0]["spec"]; +} +export declare const serviceSchema: Joi.ObjectSchema; +export declare function serviceFromConfig(module: M, config: ServiceConfig): Service; +export declare type ServiceState = "ready" | "deploying" | "stopped" | "unhealthy" | "unknown" | "outdated" | "missing"; +export declare type ServiceProtocol = "http" | "https"; +export interface ServiceIngressSpec { + hostname?: string; + path: string; + port: number; + protocol: ServiceProtocol; +} +export interface ServiceIngress extends ServiceIngressSpec { + hostname: string; +} +export declare const ingressHostnameSchema: Joi.StringSchema; +export declare const serviceIngressSpecSchema: Joi.ObjectSchema; +export declare const serviceIngressSchema: Joi.ObjectSchema; +export interface ServiceStatus { + providerId?: string; + providerVersion?: string; + version?: string; + state?: ServiceState; + runningReplicas?: number; + ingresses?: ServiceIngress[]; + lastMessage?: string; + lastError?: string; + createdAt?: string; + updatedAt?: string; + detail?: any; +} +export declare const serviceStatusSchema: Joi.ObjectSchema; +export declare type RuntimeContext = { + envVars: PrimitiveMap; + dependencies: { + [name: string]: { + version: string; + outputs: PrimitiveMap; + }; + }; +}; +export declare const runtimeContextSchema: Joi.ObjectSchema; +export declare function prepareRuntimeContext(garden: Garden, module: Module, serviceDependencies: Service[]): Promise; +export declare function getIngressUrl(ingress: ServiceIngress): string; +//# sourceMappingURL=service.d.ts.map \ No newline at end of file diff --git a/garden-service/build/types/service.js b/garden-service/build/types/service.js new file mode 100644 index 00000000000..77233edad7c --- /dev/null +++ b/garden-service/build/types/service.js @@ -0,0 +1,181 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Joi = require("joi"); +const util_1 = require("../util/util"); +const common_1 = require("../config/common"); +const module_1 = require("./module"); +const service_1 = require("../config/service"); +const common_2 = require("../config/common"); +const dedent = require("dedent"); +const url_1 = require("url"); +const base_1 = require("../vcs/base"); +const normalizeUrl = require("normalize-url"); +exports.serviceSchema = Joi.object() + .options({ presence: "required" }) + .keys({ + name: common_1.joiIdentifier() + .description("The name of the service."), + module: Joi.object().unknown(true), + config: service_1.serviceConfigSchema, + spec: Joi.object() + .description("The raw configuration of the service (specific to each plugin)."), +}); +function serviceFromConfig(module, config) { + return { + name: config.name, + module, + config, + spec: config.spec, + }; +} +exports.serviceFromConfig = serviceFromConfig; +exports.ingressHostnameSchema = Joi.string() + .hostname() + .description(dedent ` + The hostname that should route to this service. Defaults to the default hostname configured + in the provider configuration. + + Note that if you're developing locally you may need to add this hostname to your hosts file. + `); +const portSchema = Joi.number() + .description(dedent ` + The port number that the service is exposed on internally. + This defaults to the first specified port for the service. + `); +exports.serviceIngressSpecSchema = Joi.object() + .keys({ + hostname: exports.ingressHostnameSchema, + port: portSchema, + path: Joi.string() + .default("/") + .description("The ingress path that should be matched to route to this service."), + protocol: Joi.string() + .only("http", "https") + .required() + .description("The protocol to use for the ingress."), +}); +exports.serviceIngressSchema = exports.serviceIngressSpecSchema + .keys({ + hostname: Joi.string() + .required() + .description("The hostname where the service can be accessed."), + port: portSchema + .required(), +}) + .description("A description of a deployed service ingress."); +exports.serviceStatusSchema = Joi.object() + .keys({ + providerId: Joi.string() + .description("The ID used for the service by the provider (if not the same as the service name)."), + providerVersion: Joi.string() + .description("The provider version of the deployed service (if different from the Garden module version."), + version: Joi.string() + .description("The Garden module version of the deployed service."), + state: Joi.string() + .only("ready", "deploying", "stopped", "unhealthy", "unknown", "outdated", "missing") + .default("unknown") + .description("The current deployment status of the service."), + runningReplicas: Joi.number() + .description("How many replicas of the service are currently running."), + ingresses: Joi.array() + .items(exports.serviceIngressSchema) + .description("List of currently deployed ingress endpoints for the service."), + lastMessage: Joi.string() + .allow("") + .description("Latest status message of the service (if any)."), + lastError: Joi.string() + .description("Latest error status message of the service (if any)."), + createdAt: Joi.string() + .description("When the service was first deployed by the provider."), + updatedAt: Joi.string() + .description("When the service was last updated by the provider."), + detail: Joi.object() + .meta({ extendable: true }) + .description("Additional detail, specific to the provider."), +}); +const runtimeDependencySchema = Joi.object() + .keys({ + version: base_1.moduleVersionSchema, + outputs: common_1.joiEnvVars() + .description("The outputs provided by the service (e.g. ingress URLs etc.)."), +}); +exports.runtimeContextSchema = Joi.object() + .options({ presence: "required" }) + .keys({ + envVars: Joi.object().pattern(/.+/, common_1.joiPrimitive()) + .default(() => ({}), "{}") + .unknown(false) + .description("Key/value map of environment variables. Keys must be valid POSIX environment variable names " + + "(must be uppercase) and values must be primitives."), + dependencies: common_1.joiIdentifierMap(runtimeDependencySchema) + .description("Map of all the services that this service or test depends on, and their metadata."), +}); +function prepareRuntimeContext(garden, module, serviceDependencies) { + return __awaiter(this, void 0, void 0, function* () { + const buildDepKeys = module.build.dependencies.map(dep => module_1.getModuleKey(dep.name, dep.plugin)); + const buildDependencies = yield garden.getModules(buildDepKeys); + const { versionString } = module.version; + const envVars = { + GARDEN_VERSION: versionString, + }; + for (const [key, value] of Object.entries(garden.environment.variables)) { + const envVarName = `GARDEN_VARIABLES_${key.replace(/-/g, "_").toUpperCase()}`; + envVars[envVarName] = value; + } + const deps = {}; + for (const m of buildDependencies) { + deps[m.name] = { + version: m.version.versionString, + outputs: {}, + }; + } + for (const dep of serviceDependencies) { + if (!deps[dep.name]) { + deps[dep.name] = { + version: dep.module.version.versionString, + outputs: {}, + }; + } + const depContext = deps[dep.name]; + const outputs = Object.assign({}, yield garden.actions.getServiceOutputs({ service: dep }), dep.config.outputs); + const serviceEnvName = util_1.getEnvVarName(dep.name); + common_2.validate(outputs, service_1.serviceOutputsSchema, { context: `outputs for service ${dep.name}` }); + for (const [key, value] of Object.entries(outputs)) { + const envVarName = `GARDEN_SERVICES_${serviceEnvName}_${key}`.toUpperCase(); + envVars[envVarName] = value; + depContext.outputs[key] = value; + } + } + return { + envVars, + dependencies: deps, + }; + }); +} +exports.prepareRuntimeContext = prepareRuntimeContext; +function getIngressUrl(ingress) { + return normalizeUrl(url_1.format({ + protocol: ingress.protocol, + hostname: ingress.hostname, + port: ingress.port, + pathname: ingress.path, + })); +} +exports.getIngressUrl = getIngressUrl; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["types/service.ts"],"names":[],"mappings":"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","file":"types/service.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Joi from \"joi\"\nimport { getEnvVarName } from \"../util/util\"\nimport { PrimitiveMap, joiIdentifier, joiEnvVars, joiIdentifierMap, joiPrimitive } from \"../config/common\"\nimport { Module, getModuleKey } from \"./module\"\nimport { serviceOutputsSchema, ServiceConfig, serviceConfigSchema } from \"../config/service\"\nimport { validate } from \"../config/common\"\nimport dedent = require(\"dedent\")\nimport { format } from \"url\"\nimport { moduleVersionSchema } from \"../vcs/base\"\nimport { Garden } from \"../garden\"\nimport normalizeUrl = require(\"normalize-url\")\n\nexport interface Service<M extends Module = Module> {\n  name: string\n  module: M\n  config: M[\"serviceConfigs\"][0]\n  spec: M[\"serviceConfigs\"][0][\"spec\"]\n}\n\nexport const serviceSchema = Joi.object()\n  .options({ presence: \"required\" })\n  .keys({\n    name: joiIdentifier()\n      .description(\"The name of the service.\"),\n    module: Joi.object().unknown(true),   // This causes a stack overflow: Joi.lazy(() => moduleSchema),\n    config: serviceConfigSchema,\n    spec: Joi.object()\n      .description(\"The raw configuration of the service (specific to each plugin).\"),\n  })\n\nexport function serviceFromConfig<M extends Module = Module>(module: M, config: ServiceConfig): Service<M> {\n  return {\n    name: config.name,\n    module,\n    config,\n    spec: config.spec,\n  }\n}\n\nexport type ServiceState = \"ready\" | \"deploying\" | \"stopped\" | \"unhealthy\" | \"unknown\" | \"outdated\" | \"missing\"\n\n// TODO: support TCP, UDP and gRPC\nexport type ServiceProtocol = \"http\" | \"https\"  // | \"tcp\" | \"udp\"\n\nexport interface ServiceIngressSpec {\n  hostname?: string\n  path: string\n  port: number\n  protocol: ServiceProtocol\n}\n\nexport interface ServiceIngress extends ServiceIngressSpec {\n  hostname: string\n}\n\nexport const ingressHostnameSchema = Joi.string()\n  .hostname()\n  .description(dedent`\n    The hostname that should route to this service. Defaults to the default hostname configured\n    in the provider configuration.\n\n    Note that if you're developing locally you may need to add this hostname to your hosts file.\n  `)\n\nconst portSchema = Joi.number()\n  .description(dedent`\n    The port number that the service is exposed on internally.\n    This defaults to the first specified port for the service.\n  `)\n\nexport const serviceIngressSpecSchema = Joi.object()\n  .keys({\n    hostname: ingressHostnameSchema,\n    port: portSchema,\n    path: Joi.string()\n      .default(\"/\")\n      .description(\"The ingress path that should be matched to route to this service.\"),\n    protocol: Joi.string()\n      .only(\"http\", \"https\")\n      .required()\n      .description(\"The protocol to use for the ingress.\"),\n  })\n\nexport const serviceIngressSchema = serviceIngressSpecSchema\n  .keys({\n    hostname: Joi.string()\n      .required()\n      .description(\"The hostname where the service can be accessed.\"),\n    port: portSchema\n      .required(),\n  })\n  .description(\"A description of a deployed service ingress.\")\n\n// TODO: revise this schema\nexport interface ServiceStatus {\n  providerId?: string\n  providerVersion?: string\n  version?: string\n  state?: ServiceState\n  runningReplicas?: number\n  ingresses?: ServiceIngress[],\n  lastMessage?: string\n  lastError?: string\n  createdAt?: string\n  updatedAt?: string\n  detail?: any\n}\n\nexport const serviceStatusSchema = Joi.object()\n  .keys({\n    providerId: Joi.string()\n      .description(\"The ID used for the service by the provider (if not the same as the service name).\"),\n    providerVersion: Joi.string()\n      .description(\"The provider version of the deployed service (if different from the Garden module version.\"),\n    version: Joi.string()\n      .description(\"The Garden module version of the deployed service.\"),\n    state: Joi.string()\n      .only(\"ready\", \"deploying\", \"stopped\", \"unhealthy\", \"unknown\", \"outdated\", \"missing\")\n      .default(\"unknown\")\n      .description(\"The current deployment status of the service.\"),\n    runningReplicas: Joi.number()\n      .description(\"How many replicas of the service are currently running.\"),\n    ingresses: Joi.array()\n      .items(serviceIngressSchema)\n      .description(\"List of currently deployed ingress endpoints for the service.\"),\n    lastMessage: Joi.string()\n      .allow(\"\")\n      .description(\"Latest status message of the service (if any).\"),\n    lastError: Joi.string()\n      .description(\"Latest error status message of the service (if any).\"),\n    createdAt: Joi.string()\n      .description(\"When the service was first deployed by the provider.\"),\n    updatedAt: Joi.string()\n      .description(\"When the service was last updated by the provider.\"),\n    detail: Joi.object()\n      .meta({ extendable: true })\n      .description(\"Additional detail, specific to the provider.\"),\n  })\n\nexport type RuntimeContext = {\n  envVars: PrimitiveMap\n  dependencies: {\n    [name: string]: {\n      version: string,\n      outputs: PrimitiveMap,\n    },\n  },\n}\n\nconst runtimeDependencySchema = Joi.object()\n  .keys({\n    version: moduleVersionSchema,\n    outputs: joiEnvVars()\n      .description(\"The outputs provided by the service (e.g. ingress URLs etc.).\"),\n  })\n\nexport const runtimeContextSchema = Joi.object()\n  .options({ presence: \"required\" })\n  .keys({\n    envVars: Joi.object().pattern(/.+/, joiPrimitive())\n      .default(() => ({}), \"{}\")\n      .unknown(false)\n      .description(\n        \"Key/value map of environment variables. Keys must be valid POSIX environment variable names \" +\n        \"(must be uppercase) and values must be primitives.\",\n      ),\n    dependencies: joiIdentifierMap(runtimeDependencySchema)\n      .description(\"Map of all the services that this service or test depends on, and their metadata.\"),\n  })\n\nexport async function prepareRuntimeContext(\n  garden: Garden, module: Module, serviceDependencies: Service[],\n): Promise<RuntimeContext> {\n  const buildDepKeys = module.build.dependencies.map(dep => getModuleKey(dep.name, dep.plugin))\n  const buildDependencies: Module[] = await garden.getModules(buildDepKeys)\n  const { versionString } = module.version\n  const envVars = {\n    GARDEN_VERSION: versionString,\n  }\n\n  for (const [key, value] of Object.entries(garden.environment.variables)) {\n    const envVarName = `GARDEN_VARIABLES_${key.replace(/-/g, \"_\").toUpperCase()}`\n    envVars[envVarName] = value\n  }\n\n  const deps = {}\n\n  for (const m of buildDependencies) {\n    deps[m.name] = {\n      version: m.version.versionString,\n      outputs: {},\n    }\n  }\n\n  for (const dep of serviceDependencies) {\n    if (!deps[dep.name]) {\n      deps[dep.name] = {\n        version: dep.module.version.versionString,\n        outputs: {},\n      }\n    }\n    const depContext = deps[dep.name]\n\n    const outputs = { ...await garden.actions.getServiceOutputs({ service: dep }), ...dep.config.outputs }\n    const serviceEnvName = getEnvVarName(dep.name)\n\n    validate(outputs, serviceOutputsSchema, { context: `outputs for service ${dep.name}` })\n\n    for (const [key, value] of Object.entries(outputs)) {\n      const envVarName = `GARDEN_SERVICES_${serviceEnvName}_${key}`.toUpperCase()\n\n      envVars[envVarName] = value\n      depContext.outputs[key] = value\n    }\n  }\n\n  return {\n    envVars,\n    dependencies: deps,\n  }\n}\n\nexport function getIngressUrl(ingress: ServiceIngress) {\n  return normalizeUrl(format({\n    protocol: ingress.protocol,\n    hostname: ingress.hostname,\n    port: ingress.port,\n    pathname: ingress.path,\n  }))\n}\n"]} diff --git a/garden-service/build/util/detectCycles.d.ts b/garden-service/build/util/detectCycles.d.ts new file mode 100644 index 00000000000..cd9a9c7ee0c --- /dev/null +++ b/garden-service/build/util/detectCycles.d.ts @@ -0,0 +1,6 @@ +import { Module } from "../types/module"; +import { Service } from "../types/service"; +export declare type Cycle = string[]; +export declare function detectCircularDependencies(modules: Module[], services: Service[]): Promise; +export declare function detectCycles(graph: any, vertices: string[]): Cycle[]; +//# sourceMappingURL=detectCycles.d.ts.map \ No newline at end of file diff --git a/garden-service/build/util/detectCycles.js b/garden-service/build/util/detectCycles.js new file mode 100644 index 00000000000..20c6a0446ea --- /dev/null +++ b/garden-service/build/util/detectCycles.js @@ -0,0 +1,105 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const lodash_1 = require("lodash"); +const module_1 = require("../types/module"); +const exceptions_1 = require("../exceptions"); +/* + Implements a variation on the Floyd-Warshall algorithm to compute minimal cycles. + + This is approximately O(m^3) + O(s^3), where m is the number of modules and s is the number of services. + + Throws an error if cycles were found. +*/ +function detectCircularDependencies(modules, services) { + return __awaiter(this, void 0, void 0, function* () { + // Sparse matrices + const buildGraph = {}; + const serviceGraph = {}; + /* + There's no need to account for test dependencies here, since any circularities there + are accounted for via service dependencies. + */ + for (const module of modules) { + // Build dependencies + for (const buildDep of module.build.dependencies) { + const depName = module_1.getModuleKey(buildDep.name, buildDep.plugin); + lodash_1.set(buildGraph, [module.name, depName], { distance: 1, next: depName }); + } + // Service dependencies + for (const service of module.serviceConfigs || []) { + for (const depName of service.dependencies) { + lodash_1.set(serviceGraph, [service.name, depName], { distance: 1, next: depName }); + } + } + } + const serviceNames = services.map(s => s.name); + const buildCycles = detectCycles(buildGraph, modules.map(m => m.name)); + const serviceCycles = detectCycles(serviceGraph, serviceNames); + if (buildCycles.length > 0 || serviceCycles.length > 0) { + const detail = {}; + if (buildCycles.length > 0) { + detail["circular-build-dependencies"] = cyclesToString(buildCycles); + } + if (serviceCycles.length > 0) { + detail["circular-service-dependencies"] = cyclesToString(serviceCycles); + } + throw new exceptions_1.ConfigurationError("Circular dependencies detected", detail); + } + }); +} +exports.detectCircularDependencies = detectCircularDependencies; +function detectCycles(graph, vertices) { + // Compute shortest paths + for (const k of vertices) { + for (const i of vertices) { + for (const j of vertices) { + const distanceViaK = distance(graph, i, k) + distance(graph, k, j); + if (distanceViaK < distance(graph, i, j)) { + const nextViaK = next(graph, i, k); + lodash_1.set(graph, [i, j], { distance: distanceViaK, next: nextViaK }); + } + } + } + } + // Reconstruct cycles, if any + const cycleVertices = vertices.filter(v => next(graph, v, v)); + const cycles = cycleVertices.map(v => { + const cycle = [v]; + let nextInCycle = next(graph, v, v); + while (nextInCycle !== v) { + cycle.push(nextInCycle); + nextInCycle = next(graph, nextInCycle, v); + } + return cycle; + }); + return lodash_1.uniqWith(cycles, // The concat calls below are to prevent in-place sorting. + (c1, c2) => lodash_1.isEqual(c1.concat().sort(), c2.concat().sort())); +} +exports.detectCycles = detectCycles; +function distance(graph, source, destination) { + return lodash_1.get(graph, [source, destination, "distance"], Infinity); +} +function next(graph, source, destination) { + return lodash_1.get(graph, [source, destination, "next"]); +} +function cyclesToString(cycles) { + const cycleDescriptions = cycles.map(c => lodash_1.join(c.concat([c[0]]), " <- ")); + return cycleDescriptions.length === 1 ? cycleDescriptions[0] : cycleDescriptions; +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["util/detectCycles.ts"],"names":[],"mappings":"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","file":"util/detectCycles.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { get, isEqual, join, set, uniqWith } from \"lodash\"\nimport { Module, getModuleKey } from \"../types/module\"\nimport {\n  ConfigurationError,\n} from \"../exceptions\"\nimport { Service } from \"../types/service\"\n\nexport type Cycle = string[]\n\n/*\n  Implements a variation on the Floyd-Warshall algorithm to compute minimal cycles.\n\n  This is approximately O(m^3) + O(s^3), where m is the number of modules and s is the number of services.\n\n  Throws an error if cycles were found.\n*/\nexport async function detectCircularDependencies(modules: Module[], services: Service[]) {\n  // Sparse matrices\n  const buildGraph = {}\n  const serviceGraph = {}\n\n  /*\n    There's no need to account for test dependencies here, since any circularities there\n    are accounted for via service dependencies.\n    */\n  for (const module of modules) {\n    // Build dependencies\n    for (const buildDep of module.build.dependencies) {\n      const depName = getModuleKey(buildDep.name, buildDep.plugin)\n      set(buildGraph, [module.name, depName], { distance: 1, next: depName })\n    }\n\n    // Service dependencies\n    for (const service of module.serviceConfigs || []) {\n      for (const depName of service.dependencies) {\n        set(serviceGraph, [service.name, depName], { distance: 1, next: depName })\n      }\n    }\n  }\n\n  const serviceNames = services.map(s => s.name)\n  const buildCycles = detectCycles(buildGraph, modules.map(m => m.name))\n  const serviceCycles = detectCycles(serviceGraph, serviceNames)\n\n  if (buildCycles.length > 0 || serviceCycles.length > 0) {\n    const detail = {}\n\n    if (buildCycles.length > 0) {\n      detail[\"circular-build-dependencies\"] = cyclesToString(buildCycles)\n    }\n\n    if (serviceCycles.length > 0) {\n      detail[\"circular-service-dependencies\"] = cyclesToString(serviceCycles)\n    }\n\n    throw new ConfigurationError(\"Circular dependencies detected\", detail)\n  }\n}\n\nexport function detectCycles(graph, vertices: string[]): Cycle[] {\n  // Compute shortest paths\n  for (const k of vertices) {\n    for (const i of vertices) {\n      for (const j of vertices) {\n        const distanceViaK: number = distance(graph, i, k) + distance(graph, k, j)\n        if (distanceViaK < distance(graph, i, j)) {\n          const nextViaK = next(graph, i, k)\n          set(graph, [i, j], { distance: distanceViaK, next: nextViaK })\n        }\n      }\n    }\n  }\n\n  // Reconstruct cycles, if any\n  const cycleVertices = vertices.filter(v => next(graph, v, v))\n  const cycles: Cycle[] = cycleVertices.map(v => {\n    const cycle = [v]\n    let nextInCycle = next(graph, v, v)!\n    while (nextInCycle !== v) {\n      cycle.push(nextInCycle)\n      nextInCycle = next(graph, nextInCycle, v)!\n    }\n    return cycle\n  })\n\n  return uniqWith(\n    cycles, // The concat calls below are to prevent in-place sorting.\n    (c1, c2) => isEqual(c1.concat().sort(), c2.concat().sort()))\n}\n\nfunction distance(graph, source, destination): number {\n  return get(graph, [source, destination, \"distance\"], Infinity)\n}\n\nfunction next(graph, source, destination): string | undefined {\n  return get(graph, [source, destination, \"next\"])\n}\n\nfunction cyclesToString(cycles: Cycle[]) {\n  const cycleDescriptions = cycles.map(c => join(c.concat([c[0]]), \" <- \"))\n  return cycleDescriptions.length === 1 ? cycleDescriptions[0] : cycleDescriptions\n}\n"]} diff --git a/garden-service/build/util/ext-source-util.d.ts b/garden-service/build/util/ext-source-util.d.ts new file mode 100644 index 00000000000..e541fc69f0d --- /dev/null +++ b/garden-service/build/util/ext-source-util.d.ts @@ -0,0 +1,34 @@ +import { LinkedSource } from "../config-store"; +import { Module } from "../types/module"; +import { Garden } from "../garden"; +export declare type ExternalSourceType = "project" | "module"; +export declare function getRemoteSourcesDirname(type: ExternalSourceType): string; +/** + * A remote source dir name has the format 'source-name--HASH_OF_REPO_URL' + * so that we can detect if the repo url has changed + */ +export declare function getRemoteSourcePath({ name, url, sourceType }: { + name: string; + url: string; + sourceType: ExternalSourceType; +}): string; +export declare function hashRepoUrl(url: string): string; +export declare function hasRemoteSource(module: Module): boolean; +export declare function getConfigKey(type: ExternalSourceType): string; +/** + * Check if any module is linked, including those within an external project source. + * Returns true if module path is not under the project root or alternatively if the module is a Garden module. + */ +export declare function isModuleLinked(module: Module, garden: Garden): boolean; +export declare function getLinkedSources(garden: Garden, type: ExternalSourceType): Promise; +export declare function addLinkedSources({ garden, sourceType, sources }: { + garden: Garden; + sourceType: ExternalSourceType; + sources: LinkedSource[]; +}): Promise; +export declare function removeLinkedSources({ garden, sourceType, names }: { + garden: Garden; + sourceType: ExternalSourceType; + names: string[]; +}): Promise; +//# sourceMappingURL=ext-source-util.d.ts.map \ No newline at end of file diff --git a/garden-service/build/util/ext-source-util.js b/garden-service/build/util/ext-source-util.js new file mode 100644 index 00000000000..c6fe673fd18 --- /dev/null +++ b/garden-service/build/util/ext-source-util.js @@ -0,0 +1,99 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const crypto_1 = require("crypto"); +const lodash_1 = require("lodash"); +const chalk_1 = require("chalk"); +const pathIsInside = require("path-is-inside"); +const constants_1 = require("../constants"); +const config_store_1 = require("../config-store"); +const exceptions_1 = require("../exceptions"); +const path_1 = require("path"); +function getRemoteSourcesDirname(type) { + return type === "project" ? constants_1.PROJECT_SOURCES_DIR_NAME : constants_1.MODULE_SOURCES_DIR_NAME; +} +exports.getRemoteSourcesDirname = getRemoteSourcesDirname; +/** + * A remote source dir name has the format 'source-name--HASH_OF_REPO_URL' + * so that we can detect if the repo url has changed + */ +function getRemoteSourcePath({ name, url, sourceType }) { + const dirname = name + "--" + hashRepoUrl(url); + return path_1.join(getRemoteSourcesDirname(sourceType), dirname); +} +exports.getRemoteSourcePath = getRemoteSourcePath; +function hashRepoUrl(url) { + const urlHash = crypto_1.createHash("sha256"); + urlHash.update(url); + return urlHash.digest("hex").slice(0, 10); +} +exports.hashRepoUrl = hashRepoUrl; +function hasRemoteSource(module) { + return !!module.repositoryUrl; +} +exports.hasRemoteSource = hasRemoteSource; +function getConfigKey(type) { + return type === "project" ? config_store_1.localConfigKeys.linkedProjectSources : config_store_1.localConfigKeys.linkedModuleSources; +} +exports.getConfigKey = getConfigKey; +/** + * Check if any module is linked, including those within an external project source. + * Returns true if module path is not under the project root or alternatively if the module is a Garden module. + */ +function isModuleLinked(module, garden) { + const isPluginModule = !!module.plugin; + return !pathIsInside(module.path, garden.projectRoot) && !isPluginModule; +} +exports.isModuleLinked = isModuleLinked; +function getLinkedSources(garden, type) { + return __awaiter(this, void 0, void 0, function* () { + const localConfig = yield garden.localConfigStore.get(); + return (type === "project" + ? localConfig.linkedProjectSources + : localConfig.linkedModuleSources) || []; + }); +} +exports.getLinkedSources = getLinkedSources; +function addLinkedSources({ garden, sourceType, sources }) { + return __awaiter(this, void 0, void 0, function* () { + const linked = lodash_1.uniqBy([...yield getLinkedSources(garden, sourceType), ...sources], "name"); + yield garden.localConfigStore.set([getConfigKey(sourceType)], linked); + return linked; + }); +} +exports.addLinkedSources = addLinkedSources; +function removeLinkedSources({ garden, sourceType, names }) { + return __awaiter(this, void 0, void 0, function* () { + const currentlyLinked = yield getLinkedSources(garden, sourceType); + const currentNames = currentlyLinked.map(s => s.name); + for (const name of names) { + if (!currentNames.includes(name)) { + const msg = sourceType === "project" + ? `Source ${chalk_1.default.underline(name)} is not linked. Did you mean to unlink a module?` + : `Module ${chalk_1.default.underline(name)} is not linked. Did you mean to unlink a source?`; + const errorKey = sourceType === "project" ? "currentlyLinkedSources" : "currentlyLinkedModules"; + throw new exceptions_1.ParameterError(msg, { [errorKey]: currentNames, input: names }); + } + } + const linked = currentlyLinked.filter(({ name }) => !names.includes(name)); + yield garden.localConfigStore.set([getConfigKey(sourceType)], linked); + return linked; + }); +} +exports.removeLinkedSources = removeLinkedSources; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["util/ext-source-util.ts"],"names":[],"mappings":"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","file":"util/ext-source-util.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { createHash } from \"crypto\"\nimport { uniqBy } from \"lodash\"\nimport chalk from \"chalk\"\nimport pathIsInside = require(\"path-is-inside\")\n\nimport {\n  PROJECT_SOURCES_DIR_NAME,\n  MODULE_SOURCES_DIR_NAME,\n} from \"../constants\"\nimport {\n  LinkedSource,\n  localConfigKeys,\n} from \"../config-store\"\nimport { ParameterError } from \"../exceptions\"\nimport { Module } from \"../types/module\"\nimport { join } from \"path\"\nimport { Garden } from \"../garden\"\n\nexport type ExternalSourceType = \"project\" | \"module\"\n\nexport function getRemoteSourcesDirname(type: ExternalSourceType): string {\n  return type === \"project\" ? PROJECT_SOURCES_DIR_NAME : MODULE_SOURCES_DIR_NAME\n}\n\n/**\n * A remote source dir name has the format 'source-name--HASH_OF_REPO_URL'\n * so that we can detect if the repo url has changed\n */\nexport function getRemoteSourcePath({ name, url, sourceType }:\n  { name: string, url: string, sourceType: ExternalSourceType }) {\n  const dirname = name + \"--\" + hashRepoUrl(url)\n  return join(getRemoteSourcesDirname(sourceType), dirname)\n}\n\nexport function hashRepoUrl(url: string) {\n  const urlHash = createHash(\"sha256\")\n  urlHash.update(url)\n  return urlHash.digest(\"hex\").slice(0, 10)\n}\n\nexport function hasRemoteSource(module: Module): boolean {\n  return !!module.repositoryUrl\n}\nexport function getConfigKey(type: ExternalSourceType): string {\n  return type === \"project\" ? localConfigKeys.linkedProjectSources : localConfigKeys.linkedModuleSources\n}\n\n/**\n * Check if any module is linked, including those within an external project source.\n * Returns true if module path is not under the project root or alternatively if the module is a Garden module.\n */\nexport function isModuleLinked(module: Module, garden: Garden) {\n  const isPluginModule = !!module.plugin\n  return !pathIsInside(module.path, garden.projectRoot) && !isPluginModule\n}\n\nexport async function getLinkedSources(\n  garden: Garden,\n  type: ExternalSourceType,\n): Promise<LinkedSource[]> {\n  const localConfig = await garden.localConfigStore.get()\n  return (type === \"project\"\n    ? localConfig.linkedProjectSources\n    : localConfig.linkedModuleSources) || []\n}\n\nexport async function addLinkedSources({ garden, sourceType, sources }: {\n  garden: Garden,\n  sourceType: ExternalSourceType,\n  sources: LinkedSource[],\n}): Promise<LinkedSource[]> {\n  const linked = uniqBy([...await getLinkedSources(garden, sourceType), ...sources], \"name\")\n  await garden.localConfigStore.set([getConfigKey(sourceType)], linked)\n  return linked\n}\n\nexport async function removeLinkedSources({ garden, sourceType, names }: {\n  garden: Garden,\n  sourceType: ExternalSourceType,\n  names: string[],\n}): Promise<LinkedSource[]> {\n  const currentlyLinked = await getLinkedSources(garden, sourceType)\n  const currentNames = currentlyLinked.map(s => s.name)\n\n  for (const name of names) {\n    if (!currentNames.includes(name)) {\n      const msg = sourceType === \"project\"\n        ? `Source ${chalk.underline(name)} is not linked. Did you mean to unlink a module?`\n        : `Module ${chalk.underline(name)} is not linked. Did you mean to unlink a source?`\n      const errorKey = sourceType === \"project\" ? \"currentlyLinkedSources\" : \"currentlyLinkedModules\"\n\n      throw new ParameterError(msg, { [errorKey]: currentNames, input: names })\n    }\n  }\n\n  const linked = currentlyLinked.filter(({ name }) => !names.includes(name))\n  await garden.localConfigStore.set([getConfigKey(sourceType)], linked)\n  return linked\n}\n"]} diff --git a/garden-service/build/util/is-subset.d.ts b/garden-service/build/util/is-subset.d.ts new file mode 100644 index 00000000000..7477db87f8c --- /dev/null +++ b/garden-service/build/util/is-subset.d.ts @@ -0,0 +1,19 @@ +/** + * Check if an object is contained within another object. + * + * Returns `true` if: + * - all enumerable keys of *subset* are also enumerable in *superset*, and + * - every value assigned to an enumerable key of *subset* strictly equals + * the value assigned to the same key of *superset* – or is a subset of it. + * + * @param {Object} superset + * @param {Object} subset + * + * @returns {Boolean} + * + * @module is-subset + * @function default + * @alias isSubset + */ +export declare const isSubset: (superset: any, subset: any) => boolean; +//# sourceMappingURL=is-subset.d.ts.map \ No newline at end of file diff --git a/garden-service/build/util/is-subset.js b/garden-service/build/util/is-subset.js new file mode 100644 index 00000000000..375764872e8 --- /dev/null +++ b/garden-service/build/util/is-subset.js @@ -0,0 +1,45 @@ +"use strict"; +// NOTE: copied this from the is-subset package to avoid issues with their package manifest +// (https://github.com/studio-b12/is-subset/pull/9) +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Check if an object is contained within another object. + * + * Returns `true` if: + * - all enumerable keys of *subset* are also enumerable in *superset*, and + * - every value assigned to an enumerable key of *subset* strictly equals + * the value assigned to the same key of *superset* – or is a subset of it. + * + * @param {Object} superset + * @param {Object} subset + * + * @returns {Boolean} + * + * @module is-subset + * @function default + * @alias isSubset + */ +exports.isSubset = (superset, subset) => { + if ((typeof superset !== "object" || superset === null) || + (typeof subset !== "object" || subset === null)) { + return false; + } + if ((superset instanceof Date || subset instanceof Date)) { + return superset.valueOf() === subset.valueOf(); + } + return Object.keys(subset).every((key) => { + if (!superset.propertyIsEnumerable(key)) { + return false; + } + const subsetItem = subset[key]; + const supersetItem = superset[key]; + if ((typeof subsetItem === "object" && subsetItem !== null) ? + !exports.isSubset(supersetItem, subsetItem) : + supersetItem !== subsetItem) { + return false; + } + return true; + }); +}; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/util/keyed-set.d.ts b/garden-service/build/util/keyed-set.d.ts new file mode 100644 index 00000000000..018fdcf7cd0 --- /dev/null +++ b/garden-service/build/util/keyed-set.d.ts @@ -0,0 +1,13 @@ +export declare class KeyedSet { + private keyFn; + private map; + constructor(keyFn: (V: any) => string); + add(entry: V): KeyedSet; + delete(entry: V): boolean; + has(entry: V): boolean; + hasKey(key: string): boolean; + entries(): V[]; + size(): number; + clear(): void; +} +//# sourceMappingURL=keyed-set.d.ts.map \ No newline at end of file diff --git a/garden-service/build/util/keyed-set.js b/garden-service/build/util/keyed-set.js new file mode 100644 index 00000000000..568e5583f50 --- /dev/null +++ b/garden-service/build/util/keyed-set.js @@ -0,0 +1,46 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +/* + A simple set data structure that uses a custom key function for equality comparisons. + + Useful for sets of non-scalar entries, where the built-in Set data structure's === comparison is not suitable. +*/ +class KeyedSet { + constructor(keyFn) { + this.keyFn = keyFn; + this.map = new Map(); + } + add(entry) { + this.map.set(this.keyFn(entry), entry); + return this; + } + delete(entry) { + return this.map.delete(this.keyFn(entry)); + } + has(entry) { + return this.map.has(this.keyFn(entry)); + } + hasKey(key) { + return this.map.has(key); + } + // Returns set members in insertion order. + entries() { + return Array.from(this.map.values()); + } + size() { + return this.map.size; + } + clear() { + this.map = new Map(); + } +} +exports.KeyedSet = KeyedSet; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/garden-service/build/util/util.d.ts b/garden-service/build/util/util.d.ts new file mode 100644 index 00000000000..1389312f3bd --- /dev/null +++ b/garden-service/build/util/util.d.ts @@ -0,0 +1,111 @@ +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +import Bluebird = require("bluebird"); +import { ResolvableProps } from "bluebird"; +import * as klaw from "klaw"; +export declare type HookCallback = (callback?: () => void) => void; +export declare type Omit = Pick>; +export declare type Diff = T extends U ? never : T; +export declare type Nullable = { + [P in keyof T]: T[P] | null; +}; +export declare type DeepPartial = { + [P in keyof T]?: T[P] extends Array ? Array> : T[P] extends ReadonlyArray ? ReadonlyArray> : DeepPartial; +}; +export declare type Unpacked = T extends (infer U)[] ? U : T extends (...args: any[]) => infer V ? V : T extends Promise ? W : T; +export declare function shutdown(code: any): void; +export declare function registerCleanupFunction(name: string, func: HookCallback): void; +export declare function scanDirectory(path: string, opts?: klaw.Options): AsyncIterableIterator; +export declare function getChildDirNames(parentDir: string): Promise; +export declare function getIgnorer(rootPath: string): Promise; +export declare function sleep(msec: any): Promise<{}>; +export interface SpawnParams { + timeout?: number; + cwd?: string; + data?: Buffer; + ignoreError?: boolean; + env?: { + [key: string]: string | undefined; + }; +} +export interface SpawnPtyParams extends SpawnParams { + silent?: boolean; + tty?: boolean; + bufferOutput?: boolean; +} +export interface SpawnOutput { + code: number; + output: string; + stdout?: string; + stderr?: string; + proc: any; +} +export declare function spawn(cmd: string, args: string[], { timeout, cwd, data, ignoreError, env }?: SpawnParams): Promise; +export declare function spawnPty(cmd: string, args: string[], { silent, tty, timeout, cwd, bufferOutput, data, ignoreError, }?: SpawnPtyParams): Bluebird; +export declare function dumpYaml(yamlPath: any, data: any): Promise; +/** + * Encode multiple objects as one multi-doc YAML file + */ +export declare function encodeYamlMulti(objects: object[]): string; +/** + * Encode and write multiple objects as a multi-doc YAML file + */ +export declare function dumpYamlMulti(yamlPath: string, objects: object[]): Promise; +/** + * Splits the input string on the first occurrence of `delimiter`. + */ +export declare function splitFirst(s: string, delimiter: string): string[]; +/** + * Recursively resolves all promises in the given input, + * walking through all object keys and array items. + */ +export declare function deepResolve(value: T | Iterable | Iterable> | ResolvableProps): Promise | { + [K in keyof T]: T[K]; +}>; +/** + * Recursively maps over all keys in the input and resolves the resulting promises, + * walking through all object keys and array items. + */ +export declare function asyncDeepMap(obj: T, mapper: (value: any) => Promise, options?: Bluebird.ConcurrencyOption): Promise; +export declare function omitUndefined(o: object): import("_").Dictionary; +export declare function serializeObject(o: any): string; +export declare function deserializeObject(s: string): any; +export declare function serializeValues(o: { + [key: string]: any; +}): { + [key: string]: string; +}; +export declare function deserializeValues(o: object): object; +export declare function getEnumKeys(Enum: any): string[]; +export declare function highlightYaml(s: string): string; +export declare function loadYamlFile(path: string): Promise; +export interface ObjectWithName { + name: string; +} +export declare function getNames(array: T[]): string[]; +export declare function findByName(array: T[], name: string): T | undefined; +/** + * Converts a Windows-style path to a cygwin style path (e.g. C:\some\folder -> /cygdrive/c/some/folder). + */ +export declare function toCygwinPath(path: string): string; +/** + * Converts a string identifier to the appropriate casing and style for use in environment variable names. + * (e.g. "my-service" -> "MY_SERVICE") + */ +export declare function getEnvVarName(identifier: string): string; +/** + * Picks the specified keys from the given object, and throws an error if one or more keys are not found. + */ +export declare function pickKeys(obj: T, keys: U[], description?: string): Pick; +//# sourceMappingURL=util.d.ts.map \ No newline at end of file diff --git a/garden-service/build/util/util.js b/garden-service/build/util/util.js new file mode 100644 index 00000000000..af4ed0444c2 --- /dev/null +++ b/garden-service/build/util/util.js @@ -0,0 +1,423 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); } +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } +}; +var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const pty = require("node-pty-prebuilt"); +const exitHook = require("async-exit-hook"); +const klaw = require("klaw"); +const yaml = require("js-yaml"); +const Cryo = require("cryo"); +const child_process_1 = require("child_process"); +const fs_extra_1 = require("fs-extra"); +const path_1 = require("path"); +const lodash_1 = require("lodash"); +const exceptions_1 = require("../exceptions"); +const stream_1 = require("stream"); +const lodash_2 = require("lodash"); +const cli_highlight_1 = require("cli-highlight"); +const chalk_1 = require("chalk"); +const hasAnsi = require("has-ansi"); +const js_yaml_1 = require("js-yaml"); +const constants_1 = require("../constants"); +// NOTE: Importing from ignore/ignore doesn't work on Windows +const ignore = require("ignore"); +// shim to allow async generator functions +if (typeof Symbol.asyncIterator === "undefined") { + Symbol.asyncIterator = Symbol("asyncIterator"); +} +const exitHookNames = []; // For debugging/testing/inspection purposes +function shutdown(code) { + // This is a good place to log exitHookNames if needed. + process.exit(code); +} +exports.shutdown = shutdown; +function registerCleanupFunction(name, func) { + exitHookNames.push(name); + exitHook(func); +} +exports.registerCleanupFunction = registerCleanupFunction; +/* + Warning: Don't make any async calls in the loop body when using this function, since this may cause + funky concurrency behavior. + */ +function scanDirectory(path, opts) { + return __asyncGenerator(this, arguments, function* scanDirectory_1() { + let done = false; + let resolver; + let rejecter; + klaw(path, opts) + .on("data", (item) => { + if (item.path !== path) { + resolver(item); + } + }) + .on("error", (err) => { + rejecter(err); + }) + .on("end", () => { + done = true; + resolver(); + }); + // a nice little trick to turn the stream into an async generator + while (!done) { + const promise = new Promise((resolve, reject) => { + resolver = resolve; + rejecter = reject; + }); + yield yield __await(yield __await(promise)); + } + }); +} +exports.scanDirectory = scanDirectory; +function getChildDirNames(parentDir) { + return __awaiter(this, void 0, void 0, function* () { + var e_1, _a; + let dirNames = []; + // Filter on hidden dirs by default. We could make the filter function a param if needed later + const filter = (item) => !path_1.basename(item).startsWith("."); + try { + for (var _b = __asyncValues(scanDirectory(parentDir, { depthLimit: 0, filter })), _c; _c = yield _b.next(), !_c.done;) { + const item = _c.value; + if (!item || !item.stats.isDirectory()) { + continue; + } + dirNames.push(path_1.basename(item.path)); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + return dirNames; + }); +} +exports.getChildDirNames = getChildDirNames; +function getIgnorer(rootPath) { + return __awaiter(this, void 0, void 0, function* () { + // TODO: this doesn't handle nested .gitignore files, we should revisit + const gitignorePath = path_1.join(rootPath, ".gitignore"); + const gardenignorePath = path_1.join(rootPath, ".gardenignore"); + const ig = ignore(); + if (yield fs_extra_1.pathExists(gitignorePath)) { + ig.add((yield fs_extra_1.readFile(gitignorePath)).toString()); + } + if (yield fs_extra_1.pathExists(gardenignorePath)) { + ig.add((yield fs_extra_1.readFile(gardenignorePath)).toString()); + } + // should we be adding this (or more) by default? + ig.add([ + "node_modules", + ".git", + constants_1.GARDEN_DIR_NAME, + ]); + return ig; + }); +} +exports.getIgnorer = getIgnorer; +function sleep(msec) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise(resolve => setTimeout(resolve, msec)); + }); +} +exports.sleep = sleep; +function spawn(cmd, args, { timeout = 0, cwd, data, ignoreError = false, env } = {}) { + const proc = child_process_1.spawn(cmd, args, { cwd, env }); + const result = { + code: 0, + output: "", + stdout: "", + stderr: "", + proc, + }; + proc.stdout.on("data", (s) => { + result.output += s; + result.stdout += s; + }); + proc.stderr.on("data", (s) => { + result.output += s; + result.stderr += s; + }); + if (data) { + proc.stdin.end(data); + } + return new Promise((resolve, reject) => { + let _timeout; + const _reject = (msg) => { + const err = new Error(msg); + lodash_2.extend(err, result); + reject(err); + }; + if (timeout > 0) { + _timeout = setTimeout(() => { + proc.kill("SIGKILL"); + _reject(`kubectl timed out after ${timeout} seconds.`); + }, timeout * 1000); + } + proc.on("close", (code) => { + _timeout && clearTimeout(_timeout); + result.code = code; + if (code === 0 || ignoreError) { + resolve(result); + } + else { + _reject("Process exited with code " + code); + } + }); + }); +} +exports.spawn = spawn; +function spawnPty(cmd, args, { silent = false, tty = false, timeout = 0, cwd, bufferOutput = true, data, ignoreError = false, } = {}) { + let _process = process; + let proc = pty.spawn(cmd, args, { + cwd, + name: "xterm-color", + cols: _process.stdout.columns, + rows: _process.stdout.rows, + }); + _process.stdin.setEncoding("utf8"); + // raw mode is not available if we're running without a TTY + tty && _process.stdin.setRawMode && _process.stdin.setRawMode(true); + const result = { + code: 0, + output: "", + proc, + }; + proc.on("data", (output) => { + const str = output.toString(); + if (bufferOutput) { + result.output += str; + } + if (!silent) { + process.stdout.write(hasAnsi(str) ? str : chalk_1.default.white(str)); + } + }); + if (data) { + const bufferStream = new stream_1.PassThrough(); + bufferStream.end(data + "\n\0"); + bufferStream.pipe(proc); + proc.end(); + } + if (tty) { + process.stdin.pipe(proc); + } + return new Bluebird((resolve, _reject) => { + let _timeout; + const reject = (err) => { + err.output = result.output; + err.proc = result.proc; + console.log(err.output); + _reject(err); + }; + if (timeout > 0) { + _timeout = setTimeout(() => { + proc.kill("SIGKILL"); + const err = new exceptions_1.TimeoutError(`${cmd} command timed out after ${timeout} seconds.`, { cmd, timeout }); + reject(err); + }, timeout * 1000); + } + proc.on("exit", (code) => { + _timeout && clearTimeout(_timeout); + // make sure raw input is decoupled + tty && _process.stdin.setRawMode && _process.stdin.setRawMode(false); + result.code = code; + if (code === 0 || ignoreError) { + resolve(result); + } + else { + const err = new Error("Process exited with code " + code); + err.code = code; + reject(err); + } + }); + }); +} +exports.spawnPty = spawnPty; +function dumpYaml(yamlPath, data) { + return __awaiter(this, void 0, void 0, function* () { + return fs_extra_1.writeFile(yamlPath, yaml.safeDump(data, { noRefs: true })); + }); +} +exports.dumpYaml = dumpYaml; +/** + * Encode multiple objects as one multi-doc YAML file + */ +function encodeYamlMulti(objects) { + return objects.map(s => js_yaml_1.safeDump(s) + "---\n").join(""); +} +exports.encodeYamlMulti = encodeYamlMulti; +/** + * Encode and write multiple objects as a multi-doc YAML file + */ +function dumpYamlMulti(yamlPath, objects) { + return __awaiter(this, void 0, void 0, function* () { + return fs_extra_1.writeFile(yamlPath, encodeYamlMulti(objects)); + }); +} +exports.dumpYamlMulti = dumpYamlMulti; +/** + * Splits the input string on the first occurrence of `delimiter`. + */ +function splitFirst(s, delimiter) { + const parts = s.split(delimiter); + return [parts[0], parts.slice(1).join(delimiter)]; +} +exports.splitFirst = splitFirst; +/** + * Recursively resolves all promises in the given input, + * walking through all object keys and array items. + */ +function deepResolve(value) { + return __awaiter(this, void 0, void 0, function* () { + if (lodash_2.isArray(value)) { + return yield Bluebird.map(value, deepResolve); + } + else if (lodash_2.isPlainObject(value)) { + return yield Bluebird.props(lodash_2.mapValues(value, deepResolve)); + } + else { + return Promise.resolve(value); + } + }); +} +exports.deepResolve = deepResolve; +/** + * Recursively maps over all keys in the input and resolves the resulting promises, + * walking through all object keys and array items. + */ +function asyncDeepMap(obj, mapper, options) { + return __awaiter(this, void 0, void 0, function* () { + if (lodash_2.isArray(obj)) { + return Bluebird.map(obj, v => asyncDeepMap(v, mapper, options), options); + } + else if (lodash_2.isPlainObject(obj)) { + return lodash_1.fromPairs(yield Bluebird.map(Object.entries(obj), ([key, value]) => __awaiter(this, void 0, void 0, function* () { return [key, yield asyncDeepMap(value, mapper, options)]; }), options)); + } + else { + return mapper(obj); + } + }); +} +exports.asyncDeepMap = asyncDeepMap; +function omitUndefined(o) { + return lodash_2.pickBy(o, (v) => v !== undefined); +} +exports.omitUndefined = omitUndefined; +function serializeObject(o) { + return Buffer.from(Cryo.stringify(o)).toString("base64"); +} +exports.serializeObject = serializeObject; +function deserializeObject(s) { + return Cryo.parse(Buffer.from(s, "base64")); +} +exports.deserializeObject = deserializeObject; +function serializeValues(o) { + return lodash_2.mapValues(o, serializeObject); +} +exports.serializeValues = serializeValues; +function deserializeValues(o) { + return lodash_2.mapValues(o, deserializeObject); +} +exports.deserializeValues = deserializeValues; +function getEnumKeys(Enum) { + return Object.values(Enum).filter(k => typeof k === "string"); +} +exports.getEnumKeys = getEnumKeys; +function highlightYaml(s) { + return cli_highlight_1.default(s, { + language: "yaml", + theme: { + keyword: chalk_1.default.white.italic, + literal: chalk_1.default.white.italic, + string: chalk_1.default.white, + }, + }); +} +exports.highlightYaml = highlightYaml; +function loadYamlFile(path) { + return __awaiter(this, void 0, void 0, function* () { + const fileData = yield fs_extra_1.readFile(path); + return yaml.safeLoad(fileData.toString()); + }); +} +exports.loadYamlFile = loadYamlFile; +function getNames(array) { + return array.map(v => v.name); +} +exports.getNames = getNames; +function findByName(array, name) { + return lodash_1.find(array, ["name", name]); +} +exports.findByName = findByName; +/** + * Converts a Windows-style path to a cygwin style path (e.g. C:\some\folder -> /cygdrive/c/some/folder). + */ +function toCygwinPath(path) { + const parsed = path_1.win32.parse(path); + const drive = parsed.root.split(":")[0].toLowerCase(); + const dirs = parsed.dir.split(path_1.win32.sep).slice(1); + const cygpath = path_1.posix.join("/cygdrive", drive, ...dirs, parsed.base); + // make sure trailing slash is retained + return path.endsWith(path_1.win32.sep) ? cygpath + path_1.posix.sep : cygpath; +} +exports.toCygwinPath = toCygwinPath; +/** + * Converts a string identifier to the appropriate casing and style for use in environment variable names. + * (e.g. "my-service" -> "MY_SERVICE") + */ +function getEnvVarName(identifier) { + return identifier.replace("-", "_").toUpperCase(); +} +exports.getEnvVarName = getEnvVarName; +/** + * Picks the specified keys from the given object, and throws an error if one or more keys are not found. + */ +function pickKeys(obj, keys, description = "key") { + const picked = lodash_1.pick(obj, ...keys); + const missing = lodash_1.difference(keys, Object.keys(picked)); + if (missing.length) { + throw new exceptions_1.ParameterError(`Could not find ${description}(s): ${missing.map((k, _) => k).join(", ")}`, { + missing, + available: Object.keys(obj), + }); + } + return picked; +} +exports.pickKeys = pickKeys; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["util/util.ts"],"names":[],"mappings":"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","file":"util/util.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport Bluebird = require(\"bluebird\")\nimport { ResolvableProps } from \"bluebird\"\nconst pty = require(\"node-pty-prebuilt\")\nimport * as exitHook from \"async-exit-hook\"\nimport * as klaw from \"klaw\"\nimport * as yaml from \"js-yaml\"\nimport * as Cryo from \"cryo\"\nimport { spawn as _spawn } from \"child_process\"\nimport { pathExists, readFile, writeFile } from \"fs-extra\"\nimport { join, basename, win32, posix } from \"path\"\nimport { find, pick, difference, fromPairs } from \"lodash\"\nimport { TimeoutError, ParameterError } from \"../exceptions\"\nimport { PassThrough } from \"stream\"\nimport { isArray, isPlainObject, extend, mapValues, pickBy } from \"lodash\"\nimport highlight from \"cli-highlight\"\nimport chalk from \"chalk\"\nimport hasAnsi = require(\"has-ansi\")\nimport { safeDump } from \"js-yaml\"\nimport { GARDEN_DIR_NAME } from \"../constants\"\n// NOTE: Importing from ignore/ignore doesn't work on Windows\nconst ignore = require(\"ignore\")\n\n// shim to allow async generator functions\nif (typeof (Symbol as any).asyncIterator === \"undefined\") {\n  (Symbol as any).asyncIterator = Symbol(\"asyncIterator\")\n}\n\nexport type HookCallback = (callback?: () => void) => void\n\nconst exitHookNames: string[] = [] // For debugging/testing/inspection purposes\n\nexport type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>\nexport type Diff<T, U> = T extends U ? never : T\nexport type Nullable<T> = { [P in keyof T]: T[P] | null }\n// From: https://stackoverflow.com/a/49936686/5629940\nexport type DeepPartial<T> = {\n  [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>>\n  : T[P] extends ReadonlyArray<infer V> ? ReadonlyArray<DeepPartial<V>>\n  : DeepPartial<T[P]>\n}\nexport type Unpacked<T> =\n  T extends (infer U)[] ? U\n  : T extends (...args: any[]) => infer V ? V\n  : T extends Promise<infer W> ? W\n  : T\n\nexport function shutdown(code) {\n  // This is a good place to log exitHookNames if needed.\n  process.exit(code)\n}\n\nexport function registerCleanupFunction(name: string, func: HookCallback) {\n  exitHookNames.push(name)\n  exitHook(func)\n}\n\n/*\n  Warning: Don't make any async calls in the loop body when using this function, since this may cause\n  funky concurrency behavior.\n  */\nexport async function* scanDirectory(path: string, opts?: klaw.Options): AsyncIterableIterator<klaw.Item> {\n  let done = false\n  let resolver\n  let rejecter\n\n  klaw(path, opts)\n    .on(\"data\", (item) => {\n      if (item.path !== path) {\n        resolver(item)\n      }\n    })\n    .on(\"error\", (err) => {\n      rejecter(err)\n    })\n    .on(\"end\", () => {\n      done = true\n      resolver()\n    })\n\n  // a nice little trick to turn the stream into an async generator\n  while (!done) {\n    const promise: Promise<klaw.Item> = new Promise((resolve, reject) => {\n      resolver = resolve\n      rejecter = reject\n    })\n\n    yield await promise\n  }\n}\n\nexport async function getChildDirNames(parentDir: string): Promise<string[]> {\n  let dirNames: string[] = []\n  // Filter on hidden dirs by default. We could make the filter function a param if needed later\n  const filter = (item: string) => !basename(item).startsWith(\".\")\n\n  for await (const item of scanDirectory(parentDir, { depthLimit: 0, filter })) {\n    if (!item || !item.stats.isDirectory()) {\n      continue\n    }\n    dirNames.push(basename(item.path))\n  }\n  return dirNames\n}\n\nexport async function getIgnorer(rootPath: string) {\n  // TODO: this doesn't handle nested .gitignore files, we should revisit\n  const gitignorePath = join(rootPath, \".gitignore\")\n  const gardenignorePath = join(rootPath, \".gardenignore\")\n  const ig = ignore()\n\n  if (await pathExists(gitignorePath)) {\n    ig.add((await readFile(gitignorePath)).toString())\n  }\n\n  if (await pathExists(gardenignorePath)) {\n    ig.add((await readFile(gardenignorePath)).toString())\n  }\n\n  // should we be adding this (or more) by default?\n  ig.add([\n    \"node_modules\",\n    \".git\",\n    GARDEN_DIR_NAME,\n  ])\n\n  return ig\n}\n\nexport async function sleep(msec) {\n  return new Promise(resolve => setTimeout(resolve, msec))\n}\n\nexport interface SpawnParams {\n  timeout?: number\n  cwd?: string\n  data?: Buffer\n  ignoreError?: boolean\n  env?: { [key: string]: string | undefined }\n}\n\nexport interface SpawnPtyParams extends SpawnParams {\n  silent?: boolean\n  tty?: boolean\n  bufferOutput?: boolean\n}\n\nexport interface SpawnOutput {\n  code: number\n  output: string\n  stdout?: string\n  stderr?: string\n  proc: any\n}\n\nexport function spawn(\n  cmd: string, args: string[],\n  { timeout = 0, cwd, data, ignoreError = false, env }: SpawnParams = {},\n) {\n  const proc = _spawn(cmd, args, { cwd, env })\n\n  const result: SpawnOutput = {\n    code: 0,\n    output: \"\",\n    stdout: \"\",\n    stderr: \"\",\n    proc,\n  }\n\n  proc.stdout.on(\"data\", (s) => {\n    result.output += s\n    result.stdout! += s\n  })\n\n  proc.stderr.on(\"data\", (s) => {\n    result.output += s\n    result.stderr! += s\n  })\n\n  if (data) {\n    proc.stdin.end(data)\n  }\n\n  return new Promise<SpawnOutput>((resolve, reject) => {\n    let _timeout\n\n    const _reject = (msg: string) => {\n      const err = new Error(msg)\n      extend(err, <any>result)\n      reject(err)\n    }\n\n    if (timeout > 0) {\n      _timeout = setTimeout(() => {\n        proc.kill(\"SIGKILL\")\n        _reject(`kubectl timed out after ${timeout} seconds.`)\n      }, timeout * 1000)\n    }\n\n    proc.on(\"close\", (code) => {\n      _timeout && clearTimeout(_timeout)\n      result.code = code\n\n      if (code === 0 || ignoreError) {\n        resolve(result)\n      } else {\n        _reject(\"Process exited with code \" + code)\n      }\n    })\n  })\n}\n\nexport function spawnPty(\n  cmd: string, args: string[],\n  {\n    silent = false, tty = false, timeout = 0, cwd,\n    bufferOutput = true, data, ignoreError = false,\n  }: SpawnPtyParams = {},\n): Bluebird<any> {\n  let _process = <any>process\n\n  let proc: any = pty.spawn(cmd, args, {\n    cwd,\n    name: \"xterm-color\",\n    cols: _process.stdout.columns,\n    rows: _process.stdout.rows,\n  })\n\n  _process.stdin.setEncoding(\"utf8\")\n\n  // raw mode is not available if we're running without a TTY\n  tty && _process.stdin.setRawMode && _process.stdin.setRawMode(true)\n\n  const result: SpawnOutput = {\n    code: 0,\n    output: \"\",\n    proc,\n  }\n\n  proc.on(\"data\", (output) => {\n    const str = output.toString()\n\n    if (bufferOutput) {\n      result.output += str\n    }\n\n    if (!silent) {\n      process.stdout.write(hasAnsi(str) ? str : chalk.white(str))\n    }\n  })\n\n  if (data) {\n    const bufferStream = new PassThrough()\n    bufferStream.end(data + \"\\n\\0\")\n    bufferStream.pipe(proc)\n    proc.end()\n  }\n\n  if (tty) {\n    process.stdin.pipe(proc)\n  }\n\n  return new Bluebird((resolve, _reject) => {\n    let _timeout\n\n    const reject = (err: any) => {\n      err.output = result.output\n      err.proc = result.proc\n      console.log(err.output)\n      _reject(err)\n    }\n\n    if (timeout > 0) {\n      _timeout = setTimeout(() => {\n        proc.kill(\"SIGKILL\")\n        const err = new TimeoutError(`${cmd} command timed out after ${timeout} seconds.`, { cmd, timeout })\n        reject(err)\n      }, timeout * 1000)\n    }\n\n    proc.on(\"exit\", (code) => {\n      _timeout && clearTimeout(_timeout)\n\n      // make sure raw input is decoupled\n      tty && _process.stdin.setRawMode && _process.stdin.setRawMode(false)\n      result.code = code\n\n      if (code === 0 || ignoreError) {\n        resolve(result)\n      } else {\n        const err: any = new Error(\"Process exited with code \" + code)\n        err.code = code\n        reject(err)\n      }\n    })\n  })\n}\n\nexport async function dumpYaml(yamlPath, data) {\n  return writeFile(yamlPath, yaml.safeDump(data, { noRefs: true }))\n}\n\n/**\n * Encode multiple objects as one multi-doc YAML file\n */\nexport function encodeYamlMulti(objects: object[]) {\n  return objects.map(s => safeDump(s) + \"---\\n\").join(\"\")\n}\n\n/**\n * Encode and write multiple objects as a multi-doc YAML file\n */\nexport async function dumpYamlMulti(yamlPath: string, objects: object[]) {\n  return writeFile(yamlPath, encodeYamlMulti(objects))\n}\n\n/**\n * Splits the input string on the first occurrence of `delimiter`.\n */\nexport function splitFirst(s: string, delimiter: string) {\n  const parts = s.split(delimiter)\n  return [parts[0], parts.slice(1).join(delimiter)]\n}\n\n/**\n * Recursively resolves all promises in the given input,\n * walking through all object keys and array items.\n */\nexport async function deepResolve<T>(\n  value: T | Iterable<T> | Iterable<PromiseLike<T>> | ResolvableProps<T>,\n): Promise<T | Iterable<T> | { [K in keyof T]: T[K] }> {\n  if (isArray(value)) {\n    return await Bluebird.map(value, deepResolve)\n  } else if (isPlainObject(value)) {\n    return await Bluebird.props(<ResolvableProps<T>>mapValues(<ResolvableProps<T>>value, deepResolve))\n  } else {\n    return Promise.resolve(<T>value)\n  }\n}\n\n/**\n * Recursively maps over all keys in the input and resolves the resulting promises,\n * walking through all object keys and array items.\n */\nexport async function asyncDeepMap<T>(\n  obj: T, mapper: (value) => Promise<any>, options?: Bluebird.ConcurrencyOption,\n): Promise<T> {\n  if (isArray(obj)) {\n    return <any>Bluebird.map(obj, v => asyncDeepMap(v, mapper, options), options)\n  } else if (isPlainObject(obj)) {\n    return <T>fromPairs(\n      await Bluebird.map(\n        Object.entries(obj),\n        async ([key, value]) => [key, await asyncDeepMap(value, mapper, options)],\n        options,\n      ),\n    )\n  } else {\n    return mapper(obj)\n  }\n}\n\nexport function omitUndefined(o: object) {\n  return pickBy(o, (v: any) => v !== undefined)\n}\n\nexport function serializeObject(o: any): string {\n  return Buffer.from(Cryo.stringify(o)).toString(\"base64\")\n}\n\nexport function deserializeObject(s: string) {\n  return Cryo.parse(Buffer.from(s, \"base64\"))\n}\n\nexport function serializeValues(o: { [key: string]: any }): { [key: string]: string } {\n  return mapValues(o, serializeObject)\n}\n\nexport function deserializeValues(o: object) {\n  return mapValues(o, deserializeObject)\n}\n\nexport function getEnumKeys(Enum) {\n  return Object.values(Enum).filter(k => typeof k === \"string\") as string[]\n}\n\nexport function highlightYaml(s: string) {\n  return highlight(s, {\n    language: \"yaml\",\n    theme: {\n      keyword: chalk.white.italic,\n      literal: chalk.white.italic,\n      string: chalk.white,\n    },\n  })\n}\n\nexport async function loadYamlFile(path: string): Promise<any> {\n  const fileData = await readFile(path)\n  return yaml.safeLoad(fileData.toString())\n}\n\nexport interface ObjectWithName {\n  name: string\n}\n\nexport function getNames<T extends ObjectWithName>(array: T[]) {\n  return array.map(v => v.name)\n}\n\nexport function findByName<T>(array: T[], name: string): T | undefined {\n  return find(array, [\"name\", name])\n}\n\n/**\n * Converts a Windows-style path to a cygwin style path (e.g. C:\\some\\folder -> /cygdrive/c/some/folder).\n */\nexport function toCygwinPath(path: string) {\n  const parsed = win32.parse(path)\n  const drive = parsed.root.split(\":\")[0].toLowerCase()\n  const dirs = parsed.dir.split(win32.sep).slice(1)\n  const cygpath = posix.join(\"/cygdrive\", drive, ...dirs, parsed.base)\n\n  // make sure trailing slash is retained\n  return path.endsWith(win32.sep) ? cygpath + posix.sep : cygpath\n}\n\n/**\n * Converts a string identifier to the appropriate casing and style for use in environment variable names.\n * (e.g. \"my-service\" -> \"MY_SERVICE\")\n */\nexport function getEnvVarName(identifier: string) {\n  return identifier.replace(\"-\", \"_\").toUpperCase()\n}\n\n/**\n * Picks the specified keys from the given object, and throws an error if one or more keys are not found.\n */\nexport function pickKeys<T extends object, U extends keyof T>(obj: T, keys: U[], description = \"key\"): Pick<T, U> {\n  const picked = pick(obj, ...keys)\n\n  const missing = difference(<string[]>keys, Object.keys(picked))\n\n  if (missing.length) {\n    throw new ParameterError(`Could not find ${description}(s): ${missing.map((k, _) => k).join(\", \")}`, {\n      missing,\n      available: Object.keys(obj),\n    })\n  }\n\n  return picked\n}\n"]} diff --git a/garden-service/build/vcs/base.d.ts b/garden-service/build/vcs/base.d.ts new file mode 100644 index 00000000000..35746e5279e --- /dev/null +++ b/garden-service/build/vcs/base.d.ts @@ -0,0 +1,43 @@ +import * as Joi from "joi"; +import { ExternalSourceType } from "../util/ext-source-util"; +import { ModuleConfig } from "../config/module"; +import { LogNode } from "../logger/log-node"; +export declare const NEW_MODULE_VERSION = "0000000000"; +export interface TreeVersion { + latestCommit: string; + dirtyTimestamp: number | null; +} +export interface TreeVersions { + [moduleName: string]: TreeVersion; +} +export interface ModuleVersion { + versionString: string; + dirtyTimestamp: number | null; + dependencyVersions: TreeVersions; +} +export declare const treeVersionSchema: Joi.ObjectSchema; +export declare const moduleVersionSchema: Joi.ObjectSchema; +export interface RemoteSourceParams { + url: string; + name: string; + sourceType: ExternalSourceType; + logEntry: LogNode; +} +export declare abstract class VcsHandler { + protected projectRoot: string; + constructor(projectRoot: string); + abstract name: string; + abstract getTreeVersion(path: string): Promise; + abstract ensureRemoteSource(params: RemoteSourceParams): Promise; + abstract updateRemoteSource(params: RemoteSourceParams): any; + resolveTreeVersion(path: string): Promise; + resolveVersion(moduleConfig: ModuleConfig, dependencies: ModuleConfig[]): Promise; + getRemoteSourcesDirname(type: ExternalSourceType): string; + getRemoteSourcePath(name: any, url: any, sourceType: any): string; +} +export declare function readTreeVersionFile(path: string): Promise; +export declare function writeTreeVersionFile(path: string, version: TreeVersion): Promise; +export declare function readModuleVersionFile(path: string): Promise; +export declare function writeModuleVersionFile(path: string, version: ModuleVersion): Promise; +export declare function getVersionString(treeVersion: TreeVersion): string; +//# sourceMappingURL=base.d.ts.map \ No newline at end of file diff --git a/garden-service/build/vcs/base.js b/garden-service/build/vcs/base.js new file mode 100644 index 00000000000..d50088d8b6f --- /dev/null +++ b/garden-service/build/vcs/base.js @@ -0,0 +1,191 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const Bluebird = require("bluebird"); +const lodash_1 = require("lodash"); +const crypto_1 = require("crypto"); +const Joi = require("joi"); +const common_1 = require("../config/common"); +const path_1 = require("path"); +const constants_1 = require("../constants"); +const fs_extra_1 = require("fs-extra"); +const exceptions_1 = require("../exceptions"); +const ext_source_util_1 = require("../util/ext-source-util"); +exports.NEW_MODULE_VERSION = "0000000000"; +const versionStringSchema = Joi.string() + .required() + .description("String representation of the module version."); +const dirtyTimestampSchema = Joi.number() + .allow(null) + .required() + .description("Set to the last modified time (as UNIX timestamp) if the module contains uncommitted changes, otherwise null."); +exports.treeVersionSchema = Joi.object() + .keys({ + latestCommit: Joi.string() + .required() + .description("The latest commit hash of the module source."), + dirtyTimestamp: dirtyTimestampSchema, +}); +exports.moduleVersionSchema = Joi.object() + .keys({ + versionString: versionStringSchema, + dirtyTimestamp: dirtyTimestampSchema, + dependencyVersions: Joi.object() + .pattern(/.+/, exports.treeVersionSchema) + .default(() => ({}), "{}") + .description("The version of each of the dependencies of the module."), +}); +class VcsHandler { + constructor(projectRoot) { + this.projectRoot = projectRoot; + } + resolveTreeVersion(path) { + return __awaiter(this, void 0, void 0, function* () { + // the version file is used internally to specify versions outside of source control + const versionFilePath = path_1.join(path, constants_1.GARDEN_VERSIONFILE_NAME); + const fileVersion = yield readTreeVersionFile(versionFilePath); + return fileVersion || this.getTreeVersion(path); + }); + } + resolveVersion(moduleConfig, dependencies) { + return __awaiter(this, void 0, void 0, function* () { + const treeVersion = yield this.resolveTreeVersion(moduleConfig.path); + common_1.validate(treeVersion, exports.treeVersionSchema, { + context: `${this.name} tree version for module at ${moduleConfig.path}`, + }); + if (dependencies.length === 0) { + return { + versionString: getVersionString(treeVersion), + dirtyTimestamp: treeVersion.dirtyTimestamp, + dependencyVersions: {}, + }; + } + const namedDependencyVersions = yield Bluebird.map(dependencies, (m) => __awaiter(this, void 0, void 0, function* () { return (Object.assign({ name: m.name }, yield this.resolveTreeVersion(m.path))); })); + const dependencyVersions = lodash_1.mapValues(lodash_1.keyBy(namedDependencyVersions, "name"), v => lodash_1.omit(v, "name")); + // keep the module at the top of the chain, dependencies sorted by name + const sortedDependencies = lodash_1.sortBy(namedDependencyVersions, "name"); + const allVersions = [Object.assign({ name: moduleConfig.name }, treeVersion)].concat(sortedDependencies); + const dirtyVersions = allVersions.filter(v => !!v.dirtyTimestamp); + if (dirtyVersions.length > 0) { + // if any modules are dirty, we resolve with the one(s) with the most recent timestamp + const latestDirty = []; + for (const v of lodash_1.orderBy(dirtyVersions, "dirtyTimestamp", "desc")) { + if (latestDirty.length === 0 || v.dirtyTimestamp === latestDirty[0].dirtyTimestamp) { + latestDirty.push(v); + } + else { + break; + } + } + const dirtyTimestamp = latestDirty[0].dirtyTimestamp; + if (latestDirty.length > 1) { + // if the last modified timestamp is common across multiple modules, hash their versions + const versionString = `${hashVersions(latestDirty)}-${dirtyTimestamp}`; + return { + versionString, + dirtyTimestamp, + dependencyVersions, + }; + } + else { + // if there's just one module that was most recently modified, return that version + return { + versionString: getVersionString(latestDirty[0]), + dirtyTimestamp, + dependencyVersions, + }; + } + } + else { + // otherwise derive the version from all the modules + const versionString = hashVersions(allVersions); + return { + versionString, + dirtyTimestamp: null, + dependencyVersions, + }; + } + }); + } + getRemoteSourcesDirname(type) { + return ext_source_util_1.getRemoteSourcesDirname(type); + } + getRemoteSourcePath(name, url, sourceType) { + return ext_source_util_1.getRemoteSourcePath({ name, url, sourceType }); + } +} +exports.VcsHandler = VcsHandler; +function hashVersions(versions) { + const versionHash = crypto_1.createHash("sha256"); + versionHash.update(versions.map(v => `${v.name}_${v.latestCommit}`).join(".")); + // this format is kinda arbitrary, but prefixing the "v" is useful to visually spot hashed versions + return "v" + versionHash.digest("hex").slice(0, 10); +} +function readVersionFile(path, schema) { + return __awaiter(this, void 0, void 0, function* () { + if (!(yield fs_extra_1.pathExists(path))) { + return null; + } + // this is used internally to specify version outside of source control + const versionFileContents = (yield fs_extra_1.readFile(path)).toString().trim(); + if (!versionFileContents) { + return null; + } + try { + return common_1.validate(JSON.parse(versionFileContents), schema); + } + catch (error) { + throw new exceptions_1.ConfigurationError(`Unable to parse ${path} as valid version file`, { + path, + versionFileContents, + error, + }); + } + }); +} +function readTreeVersionFile(path) { + return __awaiter(this, void 0, void 0, function* () { + return readVersionFile(path, exports.treeVersionSchema); + }); +} +exports.readTreeVersionFile = readTreeVersionFile; +function writeTreeVersionFile(path, version) { + return __awaiter(this, void 0, void 0, function* () { + yield fs_extra_1.writeFile(path, JSON.stringify(version)); + }); +} +exports.writeTreeVersionFile = writeTreeVersionFile; +function readModuleVersionFile(path) { + return __awaiter(this, void 0, void 0, function* () { + return readVersionFile(path, exports.moduleVersionSchema); + }); +} +exports.readModuleVersionFile = readModuleVersionFile; +function writeModuleVersionFile(path, version) { + return __awaiter(this, void 0, void 0, function* () { + yield fs_extra_1.writeFile(path, JSON.stringify(version)); + }); +} +exports.writeModuleVersionFile = writeModuleVersionFile; +function getVersionString(treeVersion) { + return treeVersion.dirtyTimestamp + ? `${treeVersion.latestCommit}-${treeVersion.dirtyTimestamp}` + : treeVersion.latestCommit; +} +exports.getVersionString = getVersionString; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["vcs/base.ts"],"names":[],"mappings":"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","file":"vcs/base.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport * as Bluebird from \"bluebird\"\nimport { mapValues, keyBy, sortBy, orderBy, omit } from \"lodash\"\nimport { createHash } from \"crypto\"\nimport * as Joi from \"joi\"\nimport { validate } from \"../config/common\"\nimport { join } from \"path\"\nimport { GARDEN_VERSIONFILE_NAME } from \"../constants\"\nimport { pathExists, readFile, writeFile } from \"fs-extra\"\nimport { ConfigurationError } from \"../exceptions\"\nimport {\n  ExternalSourceType,\n  getRemoteSourcesDirname,\n  getRemoteSourcePath,\n} from \"../util/ext-source-util\"\nimport { ModuleConfig } from \"../config/module\"\nimport { LogNode } from \"../logger/log-node\"\n\nexport const NEW_MODULE_VERSION = \"0000000000\"\n\nexport interface TreeVersion {\n  latestCommit: string\n  dirtyTimestamp: number | null\n}\n\nexport interface TreeVersions { [moduleName: string]: TreeVersion }\n\nexport interface ModuleVersion {\n  versionString: string\n  dirtyTimestamp: number | null\n  dependencyVersions: TreeVersions\n}\n\ninterface NamedTreeVersion extends TreeVersion {\n  name: string\n}\n\nconst versionStringSchema = Joi.string()\n  .required()\n  .description(\"String representation of the module version.\")\n\nconst dirtyTimestampSchema = Joi.number()\n  .allow(null)\n  .required()\n  .description(\n    \"Set to the last modified time (as UNIX timestamp) if the module contains uncommitted changes, otherwise null.\",\n  )\n\nexport const treeVersionSchema = Joi.object()\n  .keys({\n    latestCommit: Joi.string()\n      .required()\n      .description(\"The latest commit hash of the module source.\"),\n    dirtyTimestamp: dirtyTimestampSchema,\n  })\n\nexport const moduleVersionSchema = Joi.object()\n  .keys({\n    versionString: versionStringSchema,\n    dirtyTimestamp: dirtyTimestampSchema,\n    dependencyVersions: Joi.object()\n      .pattern(/.+/, treeVersionSchema)\n      .default(() => ({}), \"{}\")\n      .description(\"The version of each of the dependencies of the module.\"),\n  })\n\nexport interface RemoteSourceParams {\n  url: string,\n  name: string,\n  sourceType: ExternalSourceType,\n  logEntry: LogNode,\n}\n\nexport abstract class VcsHandler {\n  constructor(protected projectRoot: string) { }\n\n  abstract name: string\n  abstract async getTreeVersion(path: string): Promise<TreeVersion>\n  abstract async ensureRemoteSource(params: RemoteSourceParams): Promise<string>\n  abstract async updateRemoteSource(params: RemoteSourceParams)\n\n  async resolveTreeVersion(path: string): Promise<TreeVersion> {\n    // the version file is used internally to specify versions outside of source control\n    const versionFilePath = join(path, GARDEN_VERSIONFILE_NAME)\n    const fileVersion = await readTreeVersionFile(versionFilePath)\n    return fileVersion || this.getTreeVersion(path)\n  }\n\n  async resolveVersion(moduleConfig: ModuleConfig, dependencies: ModuleConfig[]): Promise<ModuleVersion> {\n    const treeVersion = await this.resolveTreeVersion(moduleConfig.path)\n\n    validate(treeVersion, treeVersionSchema, {\n      context: `${this.name} tree version for module at ${moduleConfig.path}`,\n    })\n\n    if (dependencies.length === 0) {\n      return {\n        versionString: getVersionString(treeVersion),\n        dirtyTimestamp: treeVersion.dirtyTimestamp,\n        dependencyVersions: {},\n      }\n    }\n\n    const namedDependencyVersions = await Bluebird.map(\n      dependencies,\n      async (m: ModuleConfig) => ({ name: m.name, ...await this.resolveTreeVersion(m.path) }),\n    )\n    const dependencyVersions = mapValues(keyBy(namedDependencyVersions, \"name\"), v => omit(v, \"name\"))\n\n    // keep the module at the top of the chain, dependencies sorted by name\n    const sortedDependencies = sortBy(namedDependencyVersions, \"name\")\n    const allVersions: NamedTreeVersion[] = [{ name: moduleConfig.name, ...treeVersion }].concat(sortedDependencies)\n\n    const dirtyVersions = allVersions.filter(v => !!v.dirtyTimestamp)\n\n    if (dirtyVersions.length > 0) {\n      // if any modules are dirty, we resolve with the one(s) with the most recent timestamp\n      const latestDirty: NamedTreeVersion[] = []\n\n      for (const v of orderBy(dirtyVersions, \"dirtyTimestamp\", \"desc\")) {\n        if (latestDirty.length === 0 || v.dirtyTimestamp === latestDirty[0].dirtyTimestamp) {\n          latestDirty.push(v)\n        } else {\n          break\n        }\n      }\n\n      const dirtyTimestamp = latestDirty[0].dirtyTimestamp\n\n      if (latestDirty.length > 1) {\n        // if the last modified timestamp is common across multiple modules, hash their versions\n        const versionString = `${hashVersions(latestDirty)}-${dirtyTimestamp}`\n\n        return {\n          versionString,\n          dirtyTimestamp,\n          dependencyVersions,\n        }\n      } else {\n        // if there's just one module that was most recently modified, return that version\n        return {\n          versionString: getVersionString(latestDirty[0]),\n          dirtyTimestamp,\n          dependencyVersions,\n        }\n      }\n    } else {\n      // otherwise derive the version from all the modules\n      const versionString = hashVersions(allVersions)\n\n      return {\n        versionString,\n        dirtyTimestamp: null,\n        dependencyVersions,\n      }\n    }\n  }\n\n  getRemoteSourcesDirname(type: ExternalSourceType) {\n    return getRemoteSourcesDirname(type)\n  }\n\n  getRemoteSourcePath(name, url, sourceType) {\n    return getRemoteSourcePath({ name, url, sourceType })\n  }\n}\n\nfunction hashVersions(versions: NamedTreeVersion[]) {\n  const versionHash = createHash(\"sha256\")\n  versionHash.update(versions.map(v => `${v.name}_${v.latestCommit}`).join(\".\"))\n  // this format is kinda arbitrary, but prefixing the \"v\" is useful to visually spot hashed versions\n  return \"v\" + versionHash.digest(\"hex\").slice(0, 10)\n}\n\nasync function readVersionFile(path: string, schema): Promise<any> {\n  if (!(await pathExists(path))) {\n    return null\n  }\n\n  // this is used internally to specify version outside of source control\n  const versionFileContents = (await readFile(path)).toString().trim()\n\n  if (!versionFileContents) {\n    return null\n  }\n\n  try {\n    return validate(JSON.parse(versionFileContents), schema)\n  } catch (error) {\n    throw new ConfigurationError(\n      `Unable to parse ${path} as valid version file`,\n      {\n        path,\n        versionFileContents,\n        error,\n      },\n    )\n  }\n}\n\nexport async function readTreeVersionFile(path: string): Promise<TreeVersion | null> {\n  return readVersionFile(path, treeVersionSchema)\n}\n\nexport async function writeTreeVersionFile(path: string, version: TreeVersion) {\n  await writeFile(path, JSON.stringify(version))\n}\n\nexport async function readModuleVersionFile(path: string): Promise<ModuleVersion | null> {\n  return readVersionFile(path, moduleVersionSchema)\n}\n\nexport async function writeModuleVersionFile(path: string, version: ModuleVersion) {\n  await writeFile(path, JSON.stringify(version))\n}\n\nexport function getVersionString(treeVersion: TreeVersion) {\n  return treeVersion.dirtyTimestamp\n    ? `${treeVersion.latestCommit}-${treeVersion.dirtyTimestamp}`\n    : treeVersion.latestCommit\n}\n"]} diff --git a/garden-service/build/vcs/git.d.ts b/garden-service/build/vcs/git.d.ts new file mode 100644 index 00000000000..fa37c0abd56 --- /dev/null +++ b/garden-service/build/vcs/git.d.ts @@ -0,0 +1,14 @@ +import { VcsHandler, RemoteSourceParams } from "./base"; +export declare const helpers: { + gitCli: (cwd: string) => (cmd: string, args: string[]) => Promise; +}; +export declare class GitHandler extends VcsHandler { + name: string; + getTreeVersion(path: string): Promise<{ + latestCommit: any; + dirtyTimestamp: number | null; + }>; + ensureRemoteSource({ url, name, logEntry, sourceType }: RemoteSourceParams): Promise; + updateRemoteSource({ url, name, sourceType, logEntry }: RemoteSourceParams): Promise; +} +//# sourceMappingURL=git.d.ts.map \ No newline at end of file diff --git a/garden-service/build/vcs/git.js b/garden-service/build/vcs/git.js new file mode 100644 index 00000000000..88364acee4f --- /dev/null +++ b/garden-service/build/vcs/git.js @@ -0,0 +1,136 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const execa = require("execa"); +const path_1 = require("path"); +const fs_extra_1 = require("fs-extra"); +const Bluebird = require("bluebird"); +const base_1 = require("./base"); +exports.helpers = { + gitCli: (cwd) => { + return (cmd, args) => __awaiter(this, void 0, void 0, function* () { + return execa.stdout("git", [cmd, ...args], { cwd }); + }); + }, +}; +function getGitUrlParts(url) { + const parts = url.split("#"); + return { repositoryUrl: parts[0], hash: parts[1] }; +} +function parseRefList(res) { + const refList = res.split("\n").map(str => { + const parts = str.split("\n"); + return { commitId: parts[0], ref: parts[1] }; + }); + return refList[0].commitId; +} +// TODO Consider moving git commands to separate (and testable) functions +class GitHandler extends base_1.VcsHandler { + constructor() { + super(...arguments); + this.name = "git"; + } + getTreeVersion(path) { + return __awaiter(this, void 0, void 0, function* () { + const git = exports.helpers.gitCli(path); + let commitHash; + try { + commitHash = (yield git("rev-list", [ + "--max-count=1", + "--abbrev-commit", + "--abbrev=10", + "HEAD", + ])) || base_1.NEW_MODULE_VERSION; + } + catch (err) { + if (err.code === 128) { + // not in a repo root, return default version + commitHash = base_1.NEW_MODULE_VERSION; + } + } + let latestDirty = 0; + const res = (yield git("diff-index", ["--name-only", "HEAD", path])) + "\n" + + (yield git("ls-files", ["--other", "--exclude-standard", path])); + const dirtyFiles = res.split("\n").filter((f) => f.length > 0); + // for dirty trees, we append the last modified time of last modified or added file + if (dirtyFiles.length) { + const repoRoot = yield git("rev-parse", ["--show-toplevel"]); + const stats = yield Bluebird.map(dirtyFiles, file => path_1.join(repoRoot, file)) + .filter((file) => fs_extra_1.pathExists(file)) + .map((file) => fs_extra_1.stat(file)); + let mtimes = stats.map((s) => Math.round(s.mtime.getTime() / 1000)); + let latest = mtimes.sort().slice(-1)[0]; + if (latest > latestDirty) { + latestDirty = latest; + } + } + return { + latestCommit: commitHash, + dirtyTimestamp: latestDirty || null, + }; + }); + } + // TODO Better auth handling + ensureRemoteSource({ url, name, logEntry, sourceType }) { + return __awaiter(this, void 0, void 0, function* () { + const remoteSourcesPath = path_1.join(this.projectRoot, this.getRemoteSourcesDirname(sourceType)); + yield fs_extra_1.ensureDir(remoteSourcesPath); + const git = exports.helpers.gitCli(remoteSourcesPath); + const absPath = path_1.join(this.projectRoot, this.getRemoteSourcePath(name, url, sourceType)); + const isCloned = yield fs_extra_1.pathExists(absPath); + if (!isCloned) { + const entry = logEntry.info({ section: name, msg: `Fetching from ${url}`, status: "active" }); + const { repositoryUrl, hash } = getGitUrlParts(url); + const cmdOpts = ["--depth=1"]; + if (hash) { + cmdOpts.push("--branch=hash"); + } + yield git("clone", [...cmdOpts, repositoryUrl, absPath]); + entry.setSuccess(); + } + return absPath; + }); + } + updateRemoteSource({ url, name, sourceType, logEntry }) { + return __awaiter(this, void 0, void 0, function* () { + const absPath = path_1.join(this.projectRoot, this.getRemoteSourcePath(name, url, sourceType)); + const git = exports.helpers.gitCli(absPath); + const { repositoryUrl, hash } = getGitUrlParts(url); + yield this.ensureRemoteSource({ url, name, sourceType, logEntry }); + const entry = logEntry.info({ section: name, msg: "Getting remote state", status: "active" }); + yield git("remote", ["update"]); + const listRemoteArgs = hash ? [repositoryUrl, hash] : [repositoryUrl]; + const showRefArgs = hash ? [hash] : []; + const remoteCommitId = parseRefList(yield git("ls-remote", listRemoteArgs)); + const localCommitId = parseRefList(yield git("show-ref", ["--hash", ...showRefArgs])); + if (localCommitId !== remoteCommitId) { + entry.setState(`Fetching from ${url}`); + const fetchArgs = hash ? ["origin", hash] : ["origin"]; + const resetArgs = hash ? [`origin/${hash}`] : ["origin"]; + yield git("fetch", ["--depth=1", ...fetchArgs]); + yield git("reset", ["--hard", ...resetArgs]); + entry.setSuccess("Source updated"); + } + else { + entry.setSuccess("Source already up to date"); + } + }); + } +} +exports.GitHandler = GitHandler; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["vcs/git.ts"],"names":[],"mappings":"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","file":"vcs/git.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport execa = require(\"execa\")\nimport { join } from \"path\"\nimport { ensureDir, pathExists, stat } from \"fs-extra\"\nimport Bluebird = require(\"bluebird\")\n\nimport { NEW_MODULE_VERSION, VcsHandler, RemoteSourceParams } from \"./base\"\n\nexport const helpers = {\n  gitCli: (cwd: string): (cmd: string, args: string[]) => Promise<string> => {\n    return async (cmd, args) => {\n      return execa.stdout(\"git\", [cmd, ...args], { cwd })\n    }\n  },\n}\n\nfunction getGitUrlParts(url: string) {\n  const parts = url.split(\"#\")\n  return { repositoryUrl: parts[0], hash: parts[1] }\n}\n\nfunction parseRefList(res: string): string {\n  const refList = res.split(\"\\n\").map(str => {\n    const parts = str.split(\"\\n\")\n    return { commitId: parts[0], ref: parts[1] }\n  })\n  return refList[0].commitId\n}\n\n// TODO Consider moving git commands to separate (and testable) functions\nexport class GitHandler extends VcsHandler {\n  name = \"git\"\n\n  async getTreeVersion(path: string) {\n    const git = helpers.gitCli(path)\n\n    let commitHash\n    try {\n      commitHash = await git(\"rev-list\", [\n        \"--max-count=1\",\n        \"--abbrev-commit\",\n        \"--abbrev=10\",\n        \"HEAD\",\n      ]) || NEW_MODULE_VERSION\n    } catch (err) {\n      if (err.code === 128) {\n        // not in a repo root, return default version\n        commitHash = NEW_MODULE_VERSION\n      }\n    }\n\n    let latestDirty = 0\n\n    const res = await git(\"diff-index\", [\"--name-only\", \"HEAD\", path]) + \"\\n\"\n      + await git(\"ls-files\", [\"--other\", \"--exclude-standard\", path])\n\n    const dirtyFiles: string[] = res.split(\"\\n\").filter((f) => f.length > 0)\n    // for dirty trees, we append the last modified time of last modified or added file\n    if (dirtyFiles.length) {\n      const repoRoot = await git(\"rev-parse\", [\"--show-toplevel\"])\n      const stats = await Bluebird.map(dirtyFiles, file => join(repoRoot, file))\n        .filter((file: string) => pathExists(file))\n        .map((file: string) => stat(file))\n\n      let mtimes = stats.map((s) => Math.round(s.mtime.getTime() / 1000))\n      let latest = mtimes.sort().slice(-1)[0]\n\n      if (latest > latestDirty) {\n        latestDirty = latest\n      }\n    }\n\n    return {\n      latestCommit: commitHash,\n      dirtyTimestamp: latestDirty || null,\n    }\n  }\n\n  // TODO Better auth handling\n  async ensureRemoteSource({ url, name, logEntry, sourceType }: RemoteSourceParams): Promise<string> {\n    const remoteSourcesPath = join(this.projectRoot, this.getRemoteSourcesDirname(sourceType))\n    await ensureDir(remoteSourcesPath)\n    const git = helpers.gitCli(remoteSourcesPath)\n\n    const absPath = join(this.projectRoot, this.getRemoteSourcePath(name, url, sourceType))\n    const isCloned = await pathExists(absPath)\n\n    if (!isCloned) {\n      const entry = logEntry.info({ section: name, msg: `Fetching from ${url}`, status: \"active\" })\n      const { repositoryUrl, hash } = getGitUrlParts(url)\n\n      const cmdOpts = [\"--depth=1\"]\n      if (hash) {\n        cmdOpts.push(\"--branch=hash\")\n      }\n\n      await git(\"clone\", [...cmdOpts, repositoryUrl, absPath])\n\n      entry.setSuccess()\n    }\n\n    return absPath\n  }\n\n  async updateRemoteSource({ url, name, sourceType, logEntry }: RemoteSourceParams) {\n    const absPath = join(this.projectRoot, this.getRemoteSourcePath(name, url, sourceType))\n    const git = helpers.gitCli(absPath)\n    const { repositoryUrl, hash } = getGitUrlParts(url)\n\n    await this.ensureRemoteSource({ url, name, sourceType, logEntry })\n\n    const entry = logEntry.info({ section: name, msg: \"Getting remote state\", status: \"active\" })\n    await git(\"remote\", [\"update\"])\n\n    const listRemoteArgs = hash ? [repositoryUrl, hash] : [repositoryUrl]\n    const showRefArgs = hash ? [hash] : []\n    const remoteCommitId = parseRefList(await git(\"ls-remote\", listRemoteArgs))\n    const localCommitId = parseRefList(await git(\"show-ref\", [\"--hash\", ...showRefArgs]))\n\n    if (localCommitId !== remoteCommitId) {\n      entry.setState(`Fetching from ${url}`)\n\n      const fetchArgs = hash ? [\"origin\", hash] : [\"origin\"]\n      const resetArgs = hash ? [`origin/${hash}`] : [\"origin\"]\n      await git(\"fetch\", [\"--depth=1\", ...fetchArgs])\n      await git(\"reset\", [\"--hard\", ...resetArgs])\n\n      entry.setSuccess(\"Source updated\")\n    } else {\n      entry.setSuccess(\"Source already up to date\")\n    }\n  }\n\n}\n"]} diff --git a/garden-service/build/watch.d.ts b/garden-service/build/watch.d.ts new file mode 100644 index 00000000000..e8687bff296 --- /dev/null +++ b/garden-service/build/watch.d.ts @@ -0,0 +1,21 @@ +import { Module } from "./types/module"; +import { Garden } from "./garden"; +export declare type AutoReloadDependants = { + [key: string]: Module[]; +}; +export declare type ChangeHandler = (module: Module | null, configChanged: boolean) => Promise; +export declare function withDependants(garden: Garden, modules: Module[], autoReloadDependants: AutoReloadDependants): Promise; +export declare function computeAutoReloadDependants(garden: Garden): Promise; +export declare class FSWatcher { + private garden; + private watcher; + constructor(garden: Garden); + watchModules(modules: Module[], changeHandler: ChangeHandler): Promise; + private makeFileChangedHandler; + private makeDirAddedHandler; + private makeDirRemovedHandler; + private invalidateCached; + private invalidateCachedForAll; + close(): void; +} +//# sourceMappingURL=watch.d.ts.map \ No newline at end of file diff --git a/garden-service/build/watch.js b/garden-service/build/watch.js new file mode 100644 index 00000000000..0882c056dde --- /dev/null +++ b/garden-service/build/watch.js @@ -0,0 +1,197 @@ +"use strict"; +/* + * Copyright (C) 2018 Garden Technologies, Inc. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const chokidar_1 = require("chokidar"); +const lodash_1 = require("lodash"); +const path_1 = require("path"); +const cache_1 = require("./cache"); +const module_1 = require("./types/module"); +const util_1 = require("./util/util"); +const constants_1 = require("./constants"); +/* + Resolves to modules and their build & service dependant modules (recursively). + Each module is represented at most once in the output. +*/ +function withDependants(garden, modules, autoReloadDependants) { + return __awaiter(this, void 0, void 0, function* () { + const moduleSet = new Set(); + const scanner = (module) => { + moduleSet.add(module.name); + for (const dependant of (autoReloadDependants[module.name] || [])) { + if (!moduleSet.has(dependant.name)) { + scanner(dependant); + } + } + }; + for (const m of modules) { + scanner(m); + } + // we retrieve the modules again to be sure we have the latest versions + return garden.getModules(Array.from(moduleSet)); + }); +} +exports.withDependants = withDependants; +function computeAutoReloadDependants(garden) { + return __awaiter(this, void 0, void 0, function* () { + const dependants = {}; + for (const module of yield garden.getModules()) { + const depModules = yield uniqueDependencyModules(garden, module); + for (const dep of depModules) { + lodash_1.set(dependants, [dep.name, module.name], module); + } + } + return lodash_1.mapValues(dependants, lodash_1.values); + }); +} +exports.computeAutoReloadDependants = computeAutoReloadDependants; +function uniqueDependencyModules(garden, module) { + return __awaiter(this, void 0, void 0, function* () { + const buildDeps = module.build.dependencies.map(d => module_1.getModuleKey(d.name, d.plugin)); + const serviceDeps = (yield garden.getServices(module.serviceDependencyNames)).map(s => s.module.name); + return garden.getModules(lodash_1.uniq(buildDeps.concat(serviceDeps))); + }); +} +class FSWatcher { + constructor(garden) { + this.garden = garden; + } + watchModules(modules, changeHandler) { + return __awaiter(this, void 0, void 0, function* () { + const projectRoot = this.garden.projectRoot; + const ignorer = yield util_1.getIgnorer(projectRoot); + const onFileChanged = this.makeFileChangedHandler(modules, changeHandler); + this.watcher = chokidar_1.watch(projectRoot, { + ignored: (path, _) => { + const relpath = path_1.relative(projectRoot, path); + return relpath && ignorer.ignores(relpath); + }, + ignoreInitial: true, + persistent: true, + }); + this.watcher + .on("add", onFileChanged) + .on("change", onFileChanged) + .on("unlink", onFileChanged); + this.watcher + .on("addDir", yield this.makeDirAddedHandler(modules, changeHandler, ignorer)) + .on("unlinkDir", this.makeDirRemovedHandler(modules, changeHandler)); + }); + } + makeFileChangedHandler(modules, changeHandler) { + return (filePath) => __awaiter(this, void 0, void 0, function* () { + const filename = path_1.basename(filePath); + if (filename === "garden.yml" || filename === ".gitignore" || filename === ".gardenignore") { + yield this.invalidateCachedForAll(); + return changeHandler(null, true); + } + const changedModule = modules.find(m => filePath.startsWith(m.path)) || null; + if (changedModule) { + this.invalidateCached(changedModule); + } + return changeHandler(changedModule, false); + }); + } + makeDirAddedHandler(modules, changeHandler, ignorer) { + return __awaiter(this, void 0, void 0, function* () { + const scanOpts = { + filter: (path) => { + const relPath = path_1.relative(this.garden.projectRoot, path); + return !ignorer.ignores(relPath); + }, + }; + return (dirPath) => __awaiter(this, void 0, void 0, function* () { + var e_1, _a; + let configChanged = false; + try { + for (var _b = __asyncValues(util_1.scanDirectory(dirPath, scanOpts)), _c; _c = yield _b.next(), !_c.done;) { + const node = _c.value; + if (!node) { + continue; + } + if (path_1.parse(node.path).base === constants_1.MODULE_CONFIG_FILENAME) { + configChanged = true; + } + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + if (configChanged) { + // The added/removed dir contains one or more garden.yml files + yield this.invalidateCachedForAll(); + return changeHandler(null, true); + } + const changedModule = modules.find(m => dirPath.startsWith(m.path)) || null; + if (changedModule) { + this.invalidateCached(changedModule); + return changeHandler(changedModule, false); + } + }); + }); + } + makeDirRemovedHandler(modules, changeHandler) { + return (dirPath) => __awaiter(this, void 0, void 0, function* () { + let changedModule = null; + for (const module of modules) { + if (module.path.startsWith(dirPath)) { + // at least one module's root dir was removed + yield this.invalidateCachedForAll(); + return changeHandler(null, true); + } + if (dirPath.startsWith(module.path)) { + // removed dir is a subdir of changedModule's root dir + if (!changedModule || module.path.startsWith(changedModule.path)) { + changedModule = module; + } + } + } + if (changedModule) { + this.invalidateCached(changedModule); + return changeHandler(changedModule, false); + } + }); + } + invalidateCached(module) { + // invalidate the cache for anything attached to the module path or upwards in the directory tree + const cacheContext = cache_1.pathToCacheContext(module.path); + this.garden.cache.invalidateUp(cacheContext); + } + invalidateCachedForAll() { + return __awaiter(this, void 0, void 0, function* () { + for (const module of yield this.garden.getModules()) { + this.invalidateCached(module); + } + }); + } + close() { + this.watcher.close(); + } +} +exports.FSWatcher = FSWatcher; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["watch.ts"],"names":[],"mappings":"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","file":"watch.js","sourcesContent":["/*\n * Copyright (C) 2018 Garden Technologies, Inc. <info@garden.io>\n *\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\nimport { watch } from \"chokidar\"\nimport {\n  mapValues,\n  set,\n  uniq,\n  values,\n} from \"lodash\"\nimport { basename, parse, relative } from \"path\"\nimport { pathToCacheContext } from \"./cache\"\nimport { Module, getModuleKey } from \"./types/module\"\nimport { getIgnorer, scanDirectory } from \"./util/util\"\nimport { MODULE_CONFIG_FILENAME } from \"./constants\"\nimport { Garden } from \"./garden\"\n\nexport type AutoReloadDependants = { [key: string]: Module[] }\nexport type ChangeHandler = (module: Module | null, configChanged: boolean) => Promise<void>\n\n/*\n  Resolves to modules and their build & service dependant modules (recursively).\n  Each module is represented at most once in the output.\n*/\nexport async function withDependants(\n  garden: Garden,\n  modules: Module[],\n  autoReloadDependants: AutoReloadDependants,\n): Promise<Module[]> {\n  const moduleSet = new Set<string>()\n\n  const scanner = (module: Module) => {\n    moduleSet.add(module.name)\n    for (const dependant of (autoReloadDependants[module.name] || [])) {\n      if (!moduleSet.has(dependant.name)) {\n        scanner(dependant)\n      }\n    }\n  }\n  for (const m of modules) {\n    scanner(m)\n  }\n\n  // we retrieve the modules again to be sure we have the latest versions\n  return garden.getModules(Array.from(moduleSet))\n}\n\nexport async function computeAutoReloadDependants(garden: Garden): Promise<AutoReloadDependants> {\n  const dependants = {}\n\n  for (const module of await garden.getModules()) {\n    const depModules: Module[] = await uniqueDependencyModules(garden, module)\n    for (const dep of depModules) {\n      set(dependants, [dep.name, module.name], module)\n    }\n  }\n\n  return mapValues(dependants, values)\n}\n\nasync function uniqueDependencyModules(garden: Garden, module: Module): Promise<Module[]> {\n  const buildDeps = module.build.dependencies.map(d => getModuleKey(d.name, d.plugin))\n  const serviceDeps = (await garden.getServices(module.serviceDependencyNames)).map(s => s.module.name)\n  return garden.getModules(uniq(buildDeps.concat(serviceDeps)))\n}\n\nexport class FSWatcher {\n  private watcher\n\n  constructor(private garden: Garden) {\n  }\n\n  async watchModules(modules: Module[], changeHandler: ChangeHandler) {\n\n    const projectRoot = this.garden.projectRoot\n    const ignorer = await getIgnorer(projectRoot)\n\n    const onFileChanged = this.makeFileChangedHandler(modules, changeHandler)\n\n    this.watcher = watch(projectRoot, {\n      ignored: (path, _) => {\n        const relpath = relative(projectRoot, path)\n        return relpath && ignorer.ignores(relpath)\n      },\n      ignoreInitial: true,\n      persistent: true,\n    })\n\n    this.watcher\n      .on(\"add\", onFileChanged)\n      .on(\"change\", onFileChanged)\n      .on(\"unlink\", onFileChanged)\n\n    this.watcher\n      .on(\"addDir\", await this.makeDirAddedHandler(modules, changeHandler, ignorer))\n      .on(\"unlinkDir\", this.makeDirRemovedHandler(modules, changeHandler))\n\n  }\n\n  private makeFileChangedHandler(modules: Module[], changeHandler: ChangeHandler) {\n\n    return async (filePath: string) => {\n\n      const filename = basename(filePath)\n      if (filename === \"garden.yml\" || filename === \".gitignore\" || filename === \".gardenignore\") {\n        await this.invalidateCachedForAll()\n        return changeHandler(null, true)\n      }\n\n      const changedModule = modules.find(m => filePath.startsWith(m.path)) || null\n\n      if (changedModule) {\n        this.invalidateCached(changedModule)\n      }\n\n      return changeHandler(changedModule, false)\n\n    }\n\n  }\n\n  private async makeDirAddedHandler(modules: Module[], changeHandler: ChangeHandler, ignorer) {\n\n    const scanOpts = {\n      filter: (path) => {\n        const relPath = relative(this.garden.projectRoot, path)\n        return !ignorer.ignores(relPath)\n      },\n    }\n\n    return async (dirPath: string) => {\n\n      let configChanged = false\n\n      for await (const node of scanDirectory(dirPath, scanOpts)) {\n        if (!node) {\n          continue\n        }\n\n        if (parse(node.path).base === MODULE_CONFIG_FILENAME) {\n          configChanged = true\n        }\n      }\n\n      if (configChanged) {\n        // The added/removed dir contains one or more garden.yml files\n        await this.invalidateCachedForAll()\n        return changeHandler(null, true)\n      }\n\n      const changedModule = modules.find(m => dirPath.startsWith(m.path)) || null\n\n      if (changedModule) {\n        this.invalidateCached(changedModule)\n        return changeHandler(changedModule, false)\n      }\n\n    }\n\n  }\n\n  private makeDirRemovedHandler(modules: Module[], changeHandler: ChangeHandler) {\n\n    return async (dirPath: string) => {\n\n      let changedModule: Module | null = null\n\n      for (const module of modules) {\n\n        if (module.path.startsWith(dirPath)) {\n          // at least one module's root dir was removed\n          await this.invalidateCachedForAll()\n          return changeHandler(null, true)\n        }\n\n        if (dirPath.startsWith(module.path)) {\n          // removed dir is a subdir of changedModule's root dir\n          if (!changedModule || module.path.startsWith(changedModule.path)) {\n            changedModule = module\n          }\n        }\n\n      }\n\n      if (changedModule) {\n        this.invalidateCached(changedModule)\n        return changeHandler(changedModule, false)\n      }\n    }\n\n  }\n\n  private invalidateCached(module: Module) {\n    // invalidate the cache for anything attached to the module path or upwards in the directory tree\n    const cacheContext = pathToCacheContext(module.path)\n    this.garden.cache.invalidateUp(cacheContext)\n  }\n\n  private async invalidateCachedForAll() {\n    for (const module of await this.garden.getModules()) {\n      this.invalidateCached(module)\n    }\n  }\n\n  close(): void {\n    this.watcher.close()\n  }\n\n}\n"]} diff --git a/garden-service/static/kubernetes/system/ingress-controller/.garden-version b/garden-service/static/kubernetes/system/ingress-controller/.garden-version new file mode 100644 index 00000000000..5994253a808 --- /dev/null +++ b/garden-service/static/kubernetes/system/ingress-controller/.garden-version @@ -0,0 +1,4 @@ +{ + "latestCommit": "4f4a7af951", + "dirtyTimestamp": null +} diff --git a/garden-service/static/kubernetes/system/kubernetes-dashboard/.garden-version b/garden-service/static/kubernetes/system/kubernetes-dashboard/.garden-version new file mode 100644 index 00000000000..5994253a808 --- /dev/null +++ b/garden-service/static/kubernetes/system/kubernetes-dashboard/.garden-version @@ -0,0 +1,4 @@ +{ + "latestCommit": "4f4a7af951", + "dirtyTimestamp": null +} diff --git a/garden-service/static/local-gcf-container/.garden-version b/garden-service/static/local-gcf-container/.garden-version new file mode 100644 index 00000000000..5994253a808 --- /dev/null +++ b/garden-service/static/local-gcf-container/.garden-version @@ -0,0 +1,4 @@ +{ + "latestCommit": "4f4a7af951", + "dirtyTimestamp": null +} diff --git a/garden-service/static/openfaas/builder/.garden-version b/garden-service/static/openfaas/builder/.garden-version new file mode 100644 index 00000000000..5994253a808 --- /dev/null +++ b/garden-service/static/openfaas/builder/.garden-version @@ -0,0 +1,4 @@ +{ + "latestCommit": "4f4a7af951", + "dirtyTimestamp": null +} diff --git a/garden-service/static/openfaas/system/openfaas-system/.garden-version b/garden-service/static/openfaas/system/openfaas-system/.garden-version new file mode 100644 index 00000000000..5994253a808 --- /dev/null +++ b/garden-service/static/openfaas/system/openfaas-system/.garden-version @@ -0,0 +1,4 @@ +{ + "latestCommit": "4f4a7af951", + "dirtyTimestamp": null +} diff --git a/package.json b/package.json index fd88b26ab6a..a22aba0e6d0 100644 --- a/package.json +++ b/package.json @@ -60,4 +60,4 @@ }, "snyk": true, "dependencies": {} -} \ No newline at end of file +}