Files
grafana/vendor/github.com/yudai/gojsondiff/README.md
T
Ben Tranter b6e46c9eb8 History and Version Control for Dashboard Updates
A simple version control system for dashboards. Closes #1504.

Goals

1. To create a new dashboard version every time a dashboard is saved.
2. To allow users to view all versions of a given dashboard.
3. To allow users to rollback to a previous version of a dashboard.
4. To allow users to compare two versions of a dashboard.

Usage

Navigate to a dashboard, and click the settings cog. From there, click
the "Changelog" button to be brought to the Changelog view. In this
view, a table containing each version of a dashboard can be seen. Each
entry in the table represents a dashboard version. A selectable
checkbox, the version number, date created, name of the user who created
that version, and commit message is shown in the table, along with a
button that allows a user to restore to a previous version of that
dashboard. If a user wants to restore to a previous version of their
dashboard, they can do so by clicking the previously mentioned button.
If a user wants to compare two different versions of a dashboard, they
can do so by clicking the checkbox of two different dashboard versions,
then clicking the "Compare versions" button located below the dashboard.
From there, the user is brought to a view showing a summary of the
dashboard differences. Each summarized change contains a link that can
be clicked to take the user a JSON diff highlighting the changes line by
line.

Overview of Changes

Backend Changes

- A `dashboard_version` table was created to store each dashboard
  version, along with a dashboard version model and structs to represent
  the queries and commands necessary for the dashboard version API
  methods.
- API endpoints were created to support working with dashboard
  versions.
- Methods were added to create, update, read, and destroy dashboard
  versions in the database.
  - Logic was added to compute the diff between two versions, and
  display it to the user.
  - The dashboard migration logic was updated to save a "Version
  1" of each existing dashboard in the database.

Frontend Changes

- New views
- Methods to pull JSON and HTML from endpoints

New API Endpoints

Each endpoint requires the authorization header to be sent in
the format,

```
Authorization: Bearer <jwt>
```

where `<jwt>` is a JSON web token obtained from the Grafana
admin panel.

`GET "/api/dashboards/db/:dashboardId/versions?orderBy=<string>&limit=<int>&start=<int>"`

Get all dashboard versions for the given dashboard ID. Accepts
three URL parameters:

- `orderBy` String to order the results by. Possible values
  are `version`, `created`, `created_by`, `message`. Default
  is `versions`. Ordering is always in descending order.
- `limit` Maximum number of results to return
- `start` Position in results to start from

`GET "/api/dashboards/db/:dashboardId/versions/:id"`

Get an individual dashboard version by ID, for the given
dashboard ID.

`POST "/api/dashboards/db/:dashboardId/restore"`

Restore to the given dashboard version. Post body is of
content-type `application/json`, and must contain.

```json
{
  "dashboardId": <int>,
  "version": <int>
}
```

`GET "/api/dashboards/db/:dashboardId/compare/:versionA...:versionB"`

Compare two dashboard versions by ID for the given
dashboard ID, returning a JSON delta formatted
representation of the diff. The URL format follows
what GitHub does. For example, visiting
[/api/dashboards/db/18/compare/22...33](http://ec2-54-80-139-44.compute-1.amazonaws.com:3000/api/dashboards/db/18/compare/22...33)
will return the diff between versions 22 and 33 for
the dashboard ID 18.

Dependencies Added

- The Go package [gojsondiff](https://github.com/yudai/gojsondiff)
  was added and vendored.
2017-05-24 19:14:39 -04:00

158 lines
2.4 KiB
Markdown

# Go JSON Diff (and Patch)
[![Wercker](https://app.wercker.com/status/00d70daaf40ce277fd4f10290f097b9d/s/master)][wercker]
[![GoDoc](https://godoc.org/github.com/yudai/gojsondiff?status.svg)][godoc]
[![MIT License](http://img.shields.io/badge/license-MIT-blue.svg)][license]
[wercker]: https://app.wercker.com/project/bykey/00d70daaf40ce277fd4f10290f097b9d
[godoc]: https://godoc.org/github.com/yudai/gojsondiff
[license]: https://github.com/yudai/gojsondiff/blob/master/LICENSE
## How to use
### Installation
```sh
go get github.com/yudai/gojsondiff
```
### Comparing two JSON strings
See `jd/main.go` for how to use this library.
## CLI tool
This repository contains a package that you can use as a CLI tool.
### Installation
```sh
go get github.com/yudai/gojsondiff/jd
```
### Usage
#### Diff
Just give two json files to the `jd` command:
```sh
jd one.json another.json
```
Outputs would be something like:
```diff
{
"arr": [
0: "arr0",
1: 21,
2: {
"num": 1,
- "str": "pek3f"
+ "str": "changed"
},
3: [
0: 0,
- 1: "1"
+ 1: "changed"
]
],
"bool": true,
"num_float": 39.39,
"num_int": 13,
"obj": {
"arr": [
0: 17,
1: "str",
2: {
- "str": "eafeb"
+ "str": "changed"
}
],
+ "new": "added",
- "num": 19,
"obj": {
- "num": 14,
+ "num": 9999
- "str": "efj3"
+ "str": "changed"
},
"str": "bcded"
},
"str": "abcde"
}
```
When you prefer the delta foramt of [jsondiffpatch](https://github.com/benjamine/jsondiffpatch), add the `-f delta` option.
```sh
jd -f delta one.json another.json
```
This command shows:
```json
{
"arr": {
"2": {
"str": [
"pek3f",
"changed"
]
},
"3": {
"1": [
"1",
"changed"
],
"_t": "a"
},
"_t": "a"
},
"obj": {
"arr": {
"2": {
"str": [
"eafeb",
"changed"
]
},
"_t": "a"
},
"new": [
"added"
],
"num": [
19,
0,
0
],
"obj": {
"num": [
14,
9999
],
"str": [
"efj3",
"changed"
]
}
}
}
```
#### Patch
Give a diff file in the delta format and the JSON file to the `jp` command.
```sh
jp diff.delta one.json
```
## License
MIT License (see `LICENSE` for detail)