Minio Memory Fix

This is a patch release for those who use Minio as their backend storage. Otherwise, feel free to continue using v0.3.0.

The minio-go client allocates ~700Mb of memory when the size of the blob is unknown. This is by design according to this issue and therefore this patch makes it so that we segment the stream into 8Mb sections and upload them to Minio during a module save operation.

This will avoid bloating the heap and so Athens running on smaller containers should work much better.

Thanks again and please give this a try and report back any issues!

v0.3.0 A.K.A Medusa ✌️ 🎉

This release brings us a lot closer to a stable and mature Go Proxy.

About 104 pull requests were poured in since last release (with nothing but love and probably some hard work).

So, a gigantic THANK YOU to all of the users, contributors, and maintainers that helped make Athens a positive open source project.

Cool Stuff You Can Now do With Go Modules and Athens

Strap in, there's a lot of new stuff here since v0.2.0!!!

1. You can now run Athens in the background for your day to day workflow. Like literally on your local development machine or on a VM in the cloud. Not just in CI/CD.

2. You can run go get (and friends) outside of a module context thanks to go 1.12, and Athens can support this seamlessly. Here's an example that illustrates what we're talking about:

   $ cd ~
   $ export GO111MODULE=on
   $ export GOPROXY=http://localhost:3000
   $ go install github.com/gomods/athens/cmd/proxy
   

   These commands will use Athens to install an Athens binary to your $GOPATH/bin directory.

3. You can run dynamic versions such as go get github.com/pkg/errors@master where @master gets translated into the latest version in that module's repository. Athens will then store that pseudo version. In other words, you can do @master and Athens will figure it out, and things will "just work". Oh, and you can also do the same thing for dynamic versions like latest and for full commit SHAs.

4. For most storage drivers, we added a /catalog endpoint that can list the modules in your storage. This endpoint is a handy way to build a simple dashboard on top of Athens.

   Want to build one of these into Athens? Come talk to us!

5. You can now opt-in to an experimental "distributed single flight" mechanism that lets you run multiple Athens instances at once, and be sure that storage persistence is done without conflict. In other words, you can run a cluster of Athens servers now!

6. You now don't need a config.toml file to run Athens. We have the defaults equally hard-coded so that new-comers don't have to worry about setting up configuration at all. For example, if you download a new Athens binary, you can just run it anywhere on your laptop with no fuss.

7. You can now filter modules by versions and not just module paths. We'll add more docs on this shortly after the release. And look for more power in the filtering syntax soon.

Breaking Change In Go Upstream

As you might know, Go 1.11.4 introduced a breaking change that broke checksum calculations. If you've been using Athens v0.2.0 and are about to upgrade to v0.3.0, you might get a "checksum mismatch" error. Here's how to fix it:

1. Locate the module path that had the checksum mismatch .
2. Delete the two lines from go.sum so that Go can recalculate the checksums for you later.
3. Delete the module@version from your Athens Storage Backend (so Go can recalculate the checksum)

To Inifinity! And Beyonnnnd!

Go Modules is still in its experimental phase but it's getting closer to being "on" by default. Until then, things might change and break in ways you don't expect (like the checksum change above!)

We're happy with the stability of Athens (some of us run Athens as a part of our regular builds!), but as always, please proceed with caution while modules is still experimental.

One More Thing

Yup, we had to quote the Apple keynotes.

As usual, we want to especially call out the amazing community behind Athens. If you have used Athens, contributed, commented on an issue, talked to us, or anything else, you're part of our community. You are an Athenian! And we can't thank you enough for being with us.

We're excited for the awesomeness to come.

Here's to the future, Athenians and Gophers.

Keep on rockin'

❤️

First Beta Release 🎉 🚀 😃

This marks our first Beta release of the Athens proxy server!

About 173 Pull Requests got merged since our last version and we cannot give enough credit and thanks to all of those who helped get Athens to where it is today.

Here's what this release means for you:

• We have tested this proxy within our own teams of contributors and maintainers, and we are confident to call it a beta. In other words, we feel this is beta quality software and that it's ready for you to use as beta on your teams
• We are ready and eager to hear your feedback if you have it
• We have upgraded our experimental public proxy, which you can access at https://athens.azurefd.net
  • Like our previous experimental server, this may have downtime, but it will use the beta
  • Follow progress of our preview here

Highlights

Here are some highlights of what's been done:

• We have worked on docs for installing, deploying, and hacking on Athens: https://docs.gomods.io
• We now support a variety of backend storage support (AWS, GCP, MongoDB and others)
• We've added logging and tracing (Jaeger and StackDriver)
• You can now authenticate Athens with your own private repositories by just providing a Github token or a .rc file

Try it out

$ docker pull gomods/athens:v0.2.0
$ docker run -p 3000:3000 gomods/athens:v0.2.0

# from another terminal window
$ cd /my/cool/project 
$ GOPROXY=http://localhost:3000 go build

A Huge Thank You

We wouldn't have gotten to this point without everyone in our community, and we always welcome new folks. Absolutely everybody is welcome, so if you're interested, we have tons of ways you can get involved. See here for details!

Enjoy!

We have an Athens proxy that works! 🎉 🎈 🍰 !

You can run GOPROXY=myproxy go get thing@version and the proxy:

• Fetches thing@version if it doesn't have it in storage
• Returns thing@version to the client
• Stores thing@version in its storage

We've verified that it works for small and medium sized projects, and we think that's pretty good 😄. Good enough for our first alpha. Yay!

A history of this release, in tweets:

• We opened a big kahuna
• We did some live pair programming (with a lot more than just a pair of people) to fix the big kahuna
• We fixed the big Kahuna and did quite a bit more
• We've been doing some awesome, awesome work to make Athens more observable, more stable, and more efficient this whole time

Each and every contributor had a massive role to play to get use from zero lines of code to this point, so thank you all!

There's some super rad stuff coming up next, including wayyyy more docs (we're even gonna have a docs site!), publishing Docker images, and of course way more features and improvements. And, oh yea, look out for a registry coming to a cloud near you 😄