maxmustermann/minio
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
minio/vendor/vendor.json

112 lines
3.3 KiB
JSON
Raw Normal View History

Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
{
"comment": "",
Migrate to golang1.5 release with GO15VENDOREXPERIMENT=1 enabled
2015-08-23 03:34:00 +02:00
"ignore": "",
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
"package": [
logrus logger
2015-09-10 05:28:09 +02:00
{
Migrate to new govendor
2015-10-11 07:28:56 +02:00
"path": "github.com/Sirupsen/logrus",
logrus logger
2015-09-10 05:28:09 +02:00
"revision": "418b41d23a1bf978c06faea5313ba194650ac088",
"revisionTime": "2015-09-08T20:46:18Z"
},
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
{
Migrate to new govendor
2015-10-11 07:28:56 +02:00
"path": "github.com/dustin/go-humanize",
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"revision": "c20a8bde38c8f5ba06f6600edf473705c96829d1",
"revisionTime": "2015-08-24T01:38:10-07:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
},
Add WebUI assetfs initial version
2015-09-25 09:37:28 +02:00
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/fatih/color",
"revision": "76d423163af754ff6423d2d9be0057fbf03c57c2",
"revisionTime": "2015-08-24T00:44:34+03:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
},
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/gorilla/context",
"revision": "1c83b3eabd45b6d76072b66b746c20815fb2872d",
"revisionTime": "2015-08-19T22:12:45-07:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
},
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/gorilla/mux",
"revision": "ee1815431e497d3850809578c93ab6705f1a19f7",
"revisionTime": "2015-08-19T22:15:06-07:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
},
First time mode for controller - Upon first time invocation ``minio controller`` would create access keys and secret id - Upon request passing 'keys' arg ``minio controller`` would provide the keys - Add colorized notification
2015-10-05 01:31:07 +02:00
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/mattn/go-isatty",
"revision": "7fcbc72f853b92b5720db4a6b8482be612daef24",
"revisionTime": "2015-08-14T09:26:29+09:00"
First time mode for controller - Upon first time invocation ``minio controller`` would create access keys and secret id - Upon request passing 'keys' arg ``minio controller`` would provide the keys - Add colorized notification
2015-10-05 01:31:07 +02:00
},
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/minio/cli",
"revision": "be072a094b77c259fcb232a3bdef6ed26760a5e6",
"revisionTime": "2015-10-13T13:54:28-07:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
},
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/minio/minio-xl/pkg/atomic",
fs: use new atomic package - use FileCreateWithPrefix() API
2015-11-18 01:32:20 +01:00
"revision": "008404af67dcf66bdde580245cd43951b425ed39",
"revisionTime": "2015-11-17T16:21:42-08:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
},
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/minio/minio-xl/pkg/cpu",
Fix portability issues for arm on raspberry pi
2015-10-20 20:22:00 +02:00
"revision": "a5fc6d2430ba2ebcab31b938ab02a42bac85dc2e",
"revisionTime": "2015-10-20T11:16:42-07:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
},
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/minio/minio-xl/pkg/crypto/sha256",
vendorize: Add new changes for sha256, sha512 for 32bit support.
2015-11-14 09:55:24 +01:00
"revision": "a4e6504a5f94cf43bdbe3dec1a622317031b145d",
"revisionTime": "2015-11-14T00:48:52-08:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
},
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/minio/minio-xl/pkg/crypto/sha512",
vendorize: Add new changes for sha256, sha512 for 32bit support.
2015-11-14 09:55:24 +01:00
"revision": "a4e6504a5f94cf43bdbe3dec1a622317031b145d",
"revisionTime": "2015-11-14T00:48:52-08:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
},
First time mode for controller - Upon first time invocation ``minio controller`` would create access keys and secret id - Upon request passing 'keys' arg ``minio controller`` would provide the keys - Add colorized notification
2015-10-05 01:31:07 +02:00
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/minio/minio-xl/pkg/minhttp",
Fix portability issues for arm on raspberry pi
2015-10-20 20:22:00 +02:00
"revision": "a5fc6d2430ba2ebcab31b938ab02a42bac85dc2e",
"revisionTime": "2015-10-20T11:16:42-07:00"
First time mode for controller - Upon first time invocation ``minio controller`` would create access keys and secret id - Upon request passing 'keys' arg ``minio controller`` would provide the keys - Add colorized notification
2015-10-05 01:31:07 +02:00
},
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/minio/minio-xl/pkg/probe",
Update new changes in probe and add setAppInfo
2015-10-25 19:11:29 +01:00
"revision": "a7b8623fd546965505f18172717393f5de4139a2",
"revisionTime": "2015-10-25T03:03:43-07:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
},
A better way to print prettified json syntax error msg
2015-09-30 00:11:46 +02:00
{
Migrate this project to minio micro services code
2015-10-16 20:26:01 +02:00
"path": "github.com/minio/minio-xl/pkg/quick",
fs: use new atomic package - use FileCreateWithPrefix() API
2015-11-18 01:32:20 +01:00
"revision": "008404af67dcf66bdde580245cd43951b425ed39",
"revisionTime": "2015-11-17T16:21:42-08:00"
A better way to print prettified json syntax error msg
2015-09-30 00:11:46 +02:00
},
Enable controller to have CORS
2015-08-31 10:47:05 +02:00
{
Migrate to new govendor
2015-10-11 07:28:56 +02:00
"path": "github.com/rs/cors",
Enable controller to have CORS
2015-08-31 10:47:05 +02:00
"revision": "eb527c8097e0f19a3ff7b253a3fe70545070f420",
"revisionTime": "2015-08-29T22:34:20-07:00"
},
First time mode for controller - Upon first time invocation ``minio controller`` would create access keys and secret id - Upon request passing 'keys' arg ``minio controller`` would provide the keys - Add colorized notification
2015-10-05 01:31:07 +02:00
{
Migrate to new govendor
2015-10-11 07:28:56 +02:00
"path": "github.com/shiena/ansicolor",
First time mode for controller - Upon first time invocation ``minio controller`` would create access keys and secret id - Upon request passing 'keys' arg ``minio controller`` would provide the keys - Add colorized notification
2015-10-05 01:31:07 +02:00
"revision": "a5e2b567a4dd6cc74545b8a4f27c9d63b9e7735b",
"revisionTime": "2015-07-19T16:15:31+09:00"
},
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
{
Migrate to new govendor
2015-10-11 07:28:56 +02:00
"path": "gopkg.in/check.v1",
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
"revision": "11d3bc7aa68e238947792f30573146a3231fc0f1",
"revisionTime": "2015-07-29T10:04:31+02:00"
Add new logging connectors
2015-10-20 08:03:01 +02:00
},
{
"path": "gopkg.in/mgo.v2",
"revision": "f402e3a216db333ae6b3ba68b9152a34a0bc6984",
"revisionTime": "2015-10-05T19:07:38-07:00"
},
{
"path": "gopkg.in/mgo.v2/bson",
"revision": "f402e3a216db333ae6b3ba68b9152a34a0bc6984",
"revisionTime": "2015-10-05T19:07:38-07:00"
},
{
"path": "gopkg.in/mgo.v2/internal/sasl",
"revision": "f402e3a216db333ae6b3ba68b9152a34a0bc6984",
"revisionTime": "2015-10-05T19:07:38-07:00"
},
{
"path": "gopkg.in/mgo.v2/internal/scram",
"revision": "f402e3a216db333ae6b3ba68b9152a34a0bc6984",
"revisionTime": "2015-10-05T19:07:38-07:00"
Migrate to govendor to avoid limitations of godep - over the course of a project history every maintainer needs to update its dependency packages, the problem essentially with godep is manipulating GOPATH - this manipulation leads to static objects created at different locations which end up conflicting with the overall functionality of golang. This also leads to broken builds. There is no easier way out of this other than asking developers to do 'godep restore' all the time. Which perhaps as a practice doesn't sound like a clean solution. On the other hand 'godep restore' has its own set of problems. - govendor is a right tool but a stop gap tool until we wait for golangs official 1.5 version which fixes this vendoring issue once and for all. - govendor provides consistency in terms of how import paths should be handled unlike manipulation GOPATH. This has advantages - no more compiled objects being referenced in GOPATH and build time GOPATH manging which leads to conflicts. - proper import paths referencing the exact package a project is dependent on. govendor is simple and provides the minimal necessary tooling to achieve this. For now this is the right solution.
2015-08-13 04:24:31 +02:00
}
]
Migrate to new govendor
2015-10-11 07:28:56 +02:00
}
Reference in a new issue Copy permalink