go mod encounters an error when trying to load one of the packages. I think the package location ("github.com/rogpeppe/go-internal/modfile") might have been moved.

go: finding github.com/rogpeppe/go-internal/modfile latest

../../../go/pkg/mod/github.com/gobuffalo/[email protected]/envy.go:26:2: unknown import path "github.com/rogpeppe/go-internal/modfile": cannot find module providing package github.com/rogpeppe/go-internal/modfile

only read parts of value， when value contain special chars ，eg “#”，

this case，how to do ？

The first 5 letters of this repository spell "Godot", which is the name of a popular open source game engine. This means that the name of this repository can be confusing at first glance, and it shows up in searches for Godot.

Perhaps go-dotenv would be a good name. It separates go from dotenv while still being mostly the same name.

If you rename the repository, the old link becomes a redirect and existing URLs and scripts will continue to work.

CC @joho

If I have for example a variable in the .env file:
Password=good#password
The library will only read good
I tried escaping the # with one or more / symbols, doesn't work. Couldn't find a way to make it work.

Function "Write" assigns the returned errors to the "error" type rather than a variable like err.

go version go1.9.2 windows/386

When I am reading from variable in my .env file which has $ in string:
MAIL_SECRET=xTvDqw$27

os.Getenv("MAIL_SECRET")
gives xTvDqw7 back, ignoring $2

why is that, have $ sign some special meaning?

The ruby dotenv has support for command substitution and basic variable substitution (but not yet expansion)

At the very least, variable substitution would be a nice to have in godotenv

I am looking to have the .env file read more as a stream. Basically I just want the environment variables to update on the fly as I modify the .env file. This would allow for zero-downtime when modifying .env variables. My application is intended to run as a daemon on a system, never shutting down unless asked to.

In the source code we have

// It's important to note that it WILL NOT OVERRIDE an env variable that already exists - consider the .env file to set dev vars or sensible defaults
func Load(filenames ...string) (err error) {
	filenames = filenamesOrDefault(filenames)

	for _, filename := range filenames {
		err = loadFile(filename, false)
		if err != nil {
			return // return early on a spazout
		}
	}
	return
}

the return // return early on a spazout behavior is questionable, in my opinion. I think it should show a normal error somehow, since it makes things easier to debug.

In my case it turned out to be an error with env file being parsed, since I had an accidental newline in one of the variables. However I couldn't figure this out without going into the dotenv source code and adding some logger statements.

My .env variable has a $ which, when printed with fmt, seems to print unexpected strings.

Perhaps something to do with unescaped characters?

Here is a test:
https://play.golang.org/p/fk9ckWoGpfT

This package is used by Gitea which is a package I'm currently working to get into Debian. This means I get to do a review of all build dependencies. While working through your project, I saw that tags are used to mark releases, but they are not being annotated.

Unannotated release tags end up causing some headaches for packaging systems that monitor upstream activity--mostly for new releases--because the information is missing from 'git describe'. To annotate a tag, it just needs the -a flag passed. (git tag -a).

If you're willing to, it's possible to update the current tags (or just latest) with annotation. I've included some links [1] [2] that explain the process.

If you choose not to update tags, it would still be hugely appreciated if you could use annotated tags in the future.

[1] http://sartak.org/2011/01/replace-a-lightweight-git-tag-with-an-annotated-tag.html
[2] http://stackoverflow.com/questions/5002555/can-a-lightweight-tag-be-converted-to-an-annotated-tag

It's time to support go modules. Because I don't love having to change import path on breaking changes there's a bit of a TODO list.

Must do

• Fix #66
• Fix #64
• Add #10
• Actually make the go module file

Maybe

• Change behaviour in #37
• Add #38

Just curious, for edge cases.

You can also use .env.local for local overrides.

Something upstream ruby has that we don't

Right now, when you open a file with godotenv and manipulate it, write it back, the values are all quoted.

In fact, that does not work out, since e.g. docker-compose does not allow those values to be quoted. So e.g.

That will work

COMPOSE_FILE=docker-compose.yml:docker-compose-dwcm.yml

while

COMPOSE_FILE="docker-compose.yml:docker-compose-dwcm.yml"

errors with
ERROR: .IOError: [Errno 2] No such file or directory: u'./"docker-compose.yml'

Any way to opt out of "quoting" values? Thanks!

You should def. only use regexp.MustCompile once for each static regexp you're creating (just throw them in global vars, they are concurrent safe) see https://golang.org/pkg/regexp/#MustCompile.

Compiling every time like it is now uses up a lot of CPU.

Very useful, thank you!

I discovered godotenv through a Go sample that uses it. I'm working on running that solution on Kubernetes. One way to solve this with Kubernetes would be to add the .env file to the container but this seems to defeat the principle of keeping config externalized.

I used ConfigMaps and am sharing it here for consideration:

There's a limitation (!) in ConfigMaps which prevents using them to map a source file containing environment variables or other properties directly into container environment variables.

The workaround is to surface the ConfigMap's contents as a volume in the container but this then requires moving the .env (or similarly named file) to a separate directory.

1. Move .env. to its own directory and revise the Golang reference. NB for convenience I'm using a relative reference here without "./" and I use an absolute reference in the container spec (step 3)

err := godotenv.Load("config/.env")

2. Convert an existing .env to a ConfigMap

kubectl create configmap env --from-file=./config/.env

3. The container spec must then reference the ConfigMap (env) through a volume mount:

spec:
  containers:
  - image: dazwilkin/configmaptest:rpi3
    imagePullPolicy: Always
    name: configmaptest
    ports:
    - name: http
      containerPort: 8080
      protocol: TCP
    volumeMounts:
    - name: config-volume
      mountPath: /config
  volumes:
    - name: config-volume
      configMap:
        name: configmaptest

This results in a container that will run on Kubernetes deriving its env settings from the pod during deployment. The same image may be used in multiple pods each using a different configuration.

Thoughts?

Is there a particular reason for NOT falling back to os.Getenv, when a variable to be expanded within another variable in the file DO NOT exist in that file?

I saw the history on issues and the PR implementing the current expansion logic, and I guess this should be following the Ruby lib behaviour - which I am not familiar with.

So I would like to know if that makes any sense, and we could think about adding such feature to use pre-existing environment variables, or not.

BTW: thanks for the package, very helpful!

When I am working on my project I am happy having my .env in the root of my git repo, however, when I run go install which points to /srv in my GOPATH environmental variable I want it to read the .env from /srv/.env. Right now I am just sym linking and this works fine, but feels a little hacky. Thoughts?

// now
_test := os.Getenv("TEST_INT")
# _test = "5" || _test = ""

// feature
_test := godotenv.GetPanic("TEST_INT")
# _test = "5" || panic("TEST_INT")

// int value
_test, err := godotenv.GetInt("NATS_test")
// _test = 5
// err = nil

env TEST_INTS=1 2 3 5
// list value
_test := godotenv.GetsPanic("TEST_INTS")
# _test =["1", "2", "3", "5"] || panic("TEST_INTS")

_test := godotenv.GetIntsPanic("TEST_INTS")
# _test = [1, 2, 3, 5] || panic("TEST_INTS")

https://github.com/alexsuslov/godotenv/blob/master/load.go

Problem: My projects usually have a stack of .env files, all of which are optional. For example, most of my projects have a .env, and allow an option .env.local, which overrides .env. And when I run tests, the tests load .env.local, then .env.test, then .env.

It would be nice to run the godotenv command with a single file argument, like when running tests: godotenv -f .env.test go test ./..., while still loading the other .env files in the right precedence order.

Proposal:

If a .env file contains a comment line like:

# import: .env.local

When encountered, godotenv would essentially Load() that other file. File not found errors would be ignored. (a "must-import" directive could be added to require the presence of the other file).

So .env files could put "overrides" up top, and "defaults" at the bottom. For example, the .env.local use case could be handled with a .env file like:

# load local developer overrides
# import: .env.local
key1=val
key2=val

The .env.test case could be handed by defining a .env.test file like:

# load local developer overrides
# import: .env.local
testkey1=value
# load defaults
# import: .env

Or, if a project wanted to have separate local overrides for both the default .env file and the .env.test file, the .env.test file could be:

# load local developer overrides
# import: .env.test.local
testkey1=value
# load defaults (which in turn loads .env.local overrides)
# import: .env

Issues: files could be loaded more than once. This shouldn't pose an issue. Circular references could occur, but could be detected by the loading code and error out.

I want to have bools inside of my .env file, right now when adding via os.Setenv() only strings are added, is this a limitation of go? I am having to strconv.PraseBool() my env variables just to get simple checks throughout my application.

#54 introduced a change that meant substitution of variables from the real environment (i.e. not that derived from .env itself) was possible.

It looks like #58 removed this behaviour, in particular the deletion of os.LookupEnv - https://github.com/joho/godotenv/pull/58/files#diff-224f281bd0a4cfe0e7dcb394e8c7a585L299. Unfortunately it isn't clear from the PR if that was intended. Any chance someone can clarify?

I think having an option of passing folder name to Load(folders ...string) or Overload(folders ...string) will help tremendously in loading all env files found. This is extremely beneficial when working with different packages where each package has its own env file within it.

I often find myself wanting to provide a set of values via the environment.
So far I've been using comma-separated values, like so

MY_LIST=val1,val2,val3

And then splitting that (strings.Split(os.Getenv("MY_LIST"), ",")).

Recently I had a bunch of values which could include commas.

Would it be possible to include some sort of support for list values? Syntax suggestion

MY_LIST[]=val1
MY_LIST[]=val2
MY_LIST[]=val3

When reading a series of files to a map, successive .env files which define a variable already set by files earlier in the list will overwrite the value of that variable. Since this is different from the behaviour of Load() (which is consistent with Load() from the reference dotenv ruby implementation), this difference should be documented.

Here's a gist for demonstration purposes

When having a value which includes quotes, godotenv seems to drop them automatically:

TEST = "echo 'asd'"

results in

echo 'asd

Short term solution by adding a space after it works for our usecase, however I doubt that this is the case in general
example that works:

TEST = "echo 'asd' "

results in

echo 'asd'

In hindsight after reading

The parser itself is pretty stupidly naive and I wouldn’t be surprised if it breaks with edge cases.

it is not particularly surprising.
Maybe this can be used as an example to make it a bit smarter?

Description

When running gotdotenv.Load:

Theres no way to check for a "FileNotFound" error.
godotenv panics as follows:

➜  server git:(master) ✗ go run main.go
panic: open .env: no such file or directory

goroutine 1 [running]:
main.main()
	.../server/main.go:12 +0xa9
exit status 2

Possible Solution

A possible solution would be to enumerate errors:

var (
        // EnvFileNotFound returns a "env file not found". Happens when godotenv is not able to find a .env file in the cwd
	EnvFileNotFound = errors.New("env file not found")
)

Then provide a ErrorIs like function, for example:

	err := godotenv.Load()

	if err != nil {
		if godotenv.ErrorIs(godotenv.EnvFileNotFound, err) {
                    // Do something
                } else {
		    return nil, err
                }
	}

Thanks in advance!

This is pretty common in Node. You load a .env locally to simulate env vars, but when deploying to production or dev server (Heroku, AWS, etc) env vars are real and are only available to the person that configured the server.

It's dangerous to store critical data in the repo such as database users, password hashes, etc.

Would be nice if there was option for fallback option if a variable is missing

Something similar to:

func env(key, fallback string) string {
value, exists := os.LookupEnv(key)
if !exists {
value = fallback
}
return value
}

Nice work here. I have my .env in the directory website/. I run go install from src/ like this

go install github.com/audrey/website

How do I run this without having .env in the root directory ie. src/ but in website/?

In my dotenv files I'm trying to keep things DRY by sourcing other dotenv files. This works great when I wish to apply a configuration to my shell environment, but it seems godotenv doesn't handle such usage.

Is there any way to accomplish usage from both the shell and godotenv load function?

hey, any chance of passing my test in

seamusabshere/dotenv@a8ad38e

?

thanks!

When you call Load() or Overload() without args it returns an error open .env: no such file or directory. There is a situation where .env file is not necessary like deploying with docker or running tests using CI tools like CircleCI where the environment can be set in other ways.
as such, it will be good if .env file is made optional so the app can use the existing os Env or get env through os.Args
EDITED:
check this comment for more #99 (comment)

Before PR #25 it was possible to have empty variables like

MYVAR=somevalue
MYOTHERVAR=

As of current version I'm receiving a panic with panic: runtime error: slice bounds out of range. Is this by design? I like to leave empty variables as placeholders and to let others know which variables can be used.

I can send the PR if necessary.

Thanks!

Function Write should defer a close on the open file and preferably sync the file that has been written by flushing the os write buffer through file.Sync() function.

Commit 992ab0e added a regexp for variable substitution but the pattern only matches digits and upper case letters. Why not lower case letters too? (I see earlier code only supported upper case too.)

I added a-z to the pattern and it made the package work on my env variables and did not break any of the unit tests. Turns out all the unit tests are for upper case variables so far. The go package doesn't have problems with lower case or mixed case variables, nor does bash.

If this is intentional, perhaps a comment in the README stating only upper case are supported for canonical reasons or something like that.

Should go without saying but just in case ... nice package. Thanks for making it available to the go community!

I get the error (EXTRA *os.PathError=open .env: no such file or directory) when I don't include any arguments in Load(). My env file is called local.env. It works if I hardcode Load("local.env")

I stick my local.env in the same directory as my main.go. Any ideas on what I'm doing wrong? Thank you.

my app does a graceful shutdown when it receives sigterm or sigint, which might take a couple seconds. But godotenv ends immediately I think.

Seems like godotenv should pass signals to the child and then wait.

Hello, testing the format .env yml the code created not read that particular variable .

INTERFACES :

• eth0
• eth2

I've added godotenv to my project and it works fine when running the compiled binary, but it fails when running my tests:

$ go test ./...
2017/10/13 16:22:37 Error loading .env fileopen .env: no such file or directory

This is happening because the tests are being run in the following temp dir location:

/var/folders/yh/7x8fqv696sb1673313nk8_m80000gn/T/go-build041463486/github.com/myrepo/identity/server/_test

and it can't find the .env file. Can anyone tell me how to fix this issue? Do I need to specify the absolute path to the .env file? I'm using the following code to load the .env file without specifying a path:

err = godotenv.Load()

if err != nil {
	log.Fatal("Error loading .env file", err)
}

I think ints and floats should not be quoted, but since all the values are strings in the Marshal method, everything is quoted.
Maybe there could be a method that accepts map[string]interface{} and then converts accordingly

Setting for example private and public PEM keys as environment variables is currently not possible.

Hi, I've got a use case where it would be beneficial to be able to output .env files as well as read them. Is that something you'd be interested in a PR for or is it out of scope for this project?

let's say I have an empty environment, and a .env file containing:

COLOR=blue

then:

$ godotenv env
COLOR=blue

Now I set COLOR to an empty value:

$ COLOR= godotenv env
COLOR=blue

I don't think it should override my setting. I tested with the ruby dotenv, it respects the env var being set, even to an empty value:

$ COLOR= dotenv env
COLOR=

Seems like the last release tag was v1, there have been a few years worth of commits since, it would be nice if a newer release tag could be created (semver style) thanks. It makes vendoring a lot easier.

Any key starting lowercase export fails to return value.

All the following will fail to return value:

export export_ export_x export_xx export_xxx export_zzzz export_env export-env export_envx exportabc export_env EXPORT_ENV export_env_settings export_env_

expor or EXPORT are fine.

I note export BAR=BAZ is valid usage.

Changing the if to check 'export ' rather than 'export' and testing specifically for key of export in godotenv.go line 256 gives the expected behaviour for me.

// Parse the key
	key = splitString[0]
	if strings.HasPrefix(key, "export") {
		key = strings.TrimPrefix(key, "export")
	}
	key = strings.Trim(key, " ")

change to

// Parse the key
	key = splitString[0]
	if strings.HasPrefix(key, "export ") && string.Trim(key, " ") != "export" {
		key = strings.TrimPrefix(key, "export")
	}
	key = strings.Trim(key, " ")

If I set something like this:

KEY='this is
a multiline
variable'

godotenv returns:

Can't separate key from value

Even though that's a valid variable assignment.

I'm currently at work; will attempt a fix later this week.

So I currently have this code:

// Env - populate app's .env file
func Env(app string, appType string) {
    // Define app's variables before writing
    envMap := map[string]string{
        "FOO" : "FOO's value",
        "BAR" : "BAR's value",
    }

    // Write to .env
    err := godotenv.Write(envMap, "/some/path/.env")
    if err != nil {
        panic(err)
    }
}

The order is not kept and it's reversed once written, the output is this:

BAR="BAR's value"
FOO="FOO's value"

Now how do you prevent it from reversing? Or will I have to write up a custom function to reverse it? I will have almost 100 lines in that map so I really don't wanna start typing up the map in reverse if I could help it. godotenv.Write() still reverses it.