@gernest What do you think about reading some config values from the ENV before reading from the config.{ json | yaml | toml } file?

I'm thinking that in some cases utron will need different values for the database connection and other configuration elements like the port depending on the environment we're running the app, for example our Production database url will be different than our development/testing URL.

Maybe utron could make the app read ENV variables and if these are not satisfied then read from the config file.

Other alternative we could do it provide environment specific configuration in the config.{json | yaml | toml} file, but in some cases reading from the ENV would be needed as well.

Again and as usual, once you agree with one of the alternatives i would be very happy to help.

I was just kicking the tires a bit with utron and didn't have a mysql or postgres environment to play around in, so I hacked in GORM's sqlite3 support.

I could be (probably) missing something here, but I figured it wouldn't hurt.

I`m start learning golang. I want to change sessionStore to redis and I found this code. Is it right? May be should be "return ctx.SessionStore.Get" ?

//GetSession retrieves session with a given name.
func (ctx *Context) GetSession(name string) (*sessions.Session, error) {
	if ctx.SessionStore != nil {
		return ctx.SessionStore.New(ctx.Request(), name)
	}
	return nil, errNoStore
}

Hi!

I write the code:

type info struct {
    c http.ResponseWriter
}

type Test struct {
    *utron.BaseController
}

func (t *Test) Index() {
    fmt.Println(info{t.Ctx.Response()})
    t.Ctx.Redirect("http://123123123.12", http.StatusFound)
}

func NewTest() *Test {
    return &Test{}
}

send many concurent requests to /test:

siege -f urls.txt -c 10 -t30s -i

and have error:

{0xc420691ee0}
{0xc4207ca000}
{0xc4207ca0d0}
{0xc4207ca1a0}
{0xc4207ca270}
{0xc4207ca340}
{0xc4206a4d00}
{0xc4206a4d00}
fatal error: concurrent map writes

goroutine 794 [running]:
runtime.throw(0x9ef0e2, 0x15)
    /usr/lib/go/src/runtime/panic.go:566 +0x95 fp=0xc420505220 sp=0xc420505200
runtime.mapassign1(0x98f7a0, 0xc4207b8c00, 0xc420505330, 0xc420505340)
    /usr/lib/go/src/runtime/hashmap.go:458 +0x8ef fp=0xc420505308 sp=0xc420505220
net/textproto.MIMEHeader.Set(0xc4207b8c00, 0x9e551b, 0x8, 0x9edaf9, 0x13)
    /usr/lib/go/src/net/textproto/header.go:22 +0xca fp=0xc420505368 sp=0xc420505308
net/http.Header.Set(0xc4207b8c00, 0x9e551b, 0x8, 0x9edaf9, 0x13)
    /usr/lib/go/src/net/http/header.go:31 +0x53 fp=0xc4205053a0 sp=0xc420505368
net/http.Redirect(0xe63320, 0xc4206a4d00, 0xc4207b3680, 0x9edaf9, 0x13, 0x12e)
    /usr/lib/go/src/net/http/server.go:1819 +0xd7 fp=0xc420505488 sp=0xc4205053a0
github.com/gernest/utron.(*Context).Redirect(0xc420174e70, 0x9edaf9, 0x13, 0x12e)
    /home/coder/go/src/github.com/gernest/utron/context.go:189 +0x5f fp=0xc4205054c8 sp=0xc420505488

...

Two parallel routines get the same context. Maybe action signature should be

func (c *SomeController) Action(ctx *utron.Context) {}

instead to save the context into the controller??

In context.go you send config to view (by default). Users can save passwords and tokens in config file. I think it`s not secure. If user will want to have config in view then he put it himself.

if c.Cfg != nil {
	c.Data["Config"] = c.Cfg // add configuration to the view data context
}

What do you think?

To use this very nice framwork, I tried to setup docker-compose. RubyOnRails and co use a much easier way to connect to databases, namely environment variables shipped by postgresl:latest container.

I setup you example inside the docker environment: https://github.com/PatWie/ultron-webapp-container

However, your library refuses the connection. A dump of available variables are:

DB_ENV_POSTGRES_USERNAME=databaseuser
DB_PORT_5432_TCP_ADDR=172.17.0.3
DB_PORT_5403_TCP=tcp://172.17.0.3:5403
DB_PORT=tcp://172.17.0.3:5403
DB_ENV_POSTGRES_PASSWORD=c9aca452d8b439b1e484855a0d4ed105
DB_ENV_LANG=en_US.utf8
DB_ENV_GOSU_VERSION=1.7
DB_PORT_5432_TCP=tcp://172.17.0.3:5432
DB_ENV_PG_MAJOR=9.5
DB_ENV_affinity:container==19e9f7ed42720d5a332c3402fb784276cb2c579e78fc304a28aef7dd1cb1fb72
DB_PORT_5403_TCP_PORT=5403
DB_ENV_POSTGRES_DBNAME=database
DB_PORT_5432_TCP_PROTO=tcp
DB_ENV_PG_VERSION=9.5.4-1.pgdg80+1
DB_PORT_5403_TCP_PROTO=tcp
DB_PORT_5403_TCP_ADDR=172.17.0.3

These should be automatically already there. So why not rely on these?

If your framework can be run inside these dockers, it would be an additional argument for using the framework.

The error-message comes from:

+ exec app
`` is not officially supported, running under compatibility mode.
2016/09/12 17:23:54 sql: unknown driver "" (forgotten import?)
hipanic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x70 pc=0x46a68a]

goroutine 1 [running]:
panic(0x8c7ec0, 0xc42000c0a0)
    /usr/local/go/src/runtime/panic.go:500 +0x1a1
github.com/gernest/utron.Run()
    /go/src/github.com/gernest/utron/utron.go:240 +0x3a
main.main()
    /go/src/app/main.go:12 +0xa4

which basically belongs to this line https://github.com/gernest/utron/blob/master/utron.go#L240

I will create a more complex example and would like help. It would be great if we had more examples.

Who can help ...

https://github.com/OsvaldoTCF/order2go

There was I, just browsing some code at Github, when I decided to read Utron's wiki. Then I stumbled upon the middlewares' page, and a doubt was spawned in my head: how the heck I would use this?Do I just have to follow the Gorilla tutorial, or make use of some gimmick to achieve that?

This commit adds recursive scanning of Config struct fields from environment variables. Embedded fields are separated by underscore. Example:

type Config struct {
  Database struct {
    Kind string
    URI string
  }
}

now reads DATABASE_KIND and DATABASE_URI environment variables.

This enables the ability to be more flexible with app configuration. You can now configure scheme and host in addition to port.

I noticed currently the server will let you configure your port in the base_url and the port in the config differently, and will tell you the base_url port is being used when it is not. This change looks for mismatches and fails instead of telling you something that isn't the case or assuming you want one over the other.

Currently you can say "localhost" but you'll actually bind to public addresses. This change in conjunction with the configuration changes will allow you to actually bind to the address you intend to via http.ListenAndServe().

I left a TODO in here to enable TLS listen, but I didn't want to implement that before checking on the rest first. If this merges I would be happy to implement the TLS listen configuration after talking through what is wanted there on gitter or issues.

In some environments I want to use the environment variables to override the default values that are set in a config file. For example, in a test environment I may want to use an empty db user (e.g. pass DB_USER="" to a particular command) .

Right now, config.go cannot distinguish between a zero-length environment variable and a environment variable that is not present.

I found the code below in session.go and I wonder this because gorilla/sessions has a method (Store) Get to retrieve a session with a given name.

//GetSession retrieves session with a given name.
func (ctx *Context) GetSession(name string) (*sessions.Session, error) {
	if ctx.SessionStore != nil {
		return ctx.SessionStore.New(ctx.Request(), name)
	}
	return nil, errNoStore
}

This is a wonderful project that has grown in leaps and bounds over time (as i have watched it for some time) and the fact that it was started by a Tanzanian is super awesome! I would suggest that a collective be opened here to enable it raise money to make more contributors give more time to work on the project and turn out releases faster the development of utron.

I've added in a change to allow the default SimpleView implementation to be replaced by a custom View implementation. Because all templates are parsed when NewMVC is called, there is no way to have templates that rely on other templates in the views directory. This change allows us to define supporting templates and add functions also.

Example usage:

utronView.SetViewFactory(func(viewDir string)(utronView.View, error){ return view.NewComplexView("fragments", viewDir, views.FuncMap) })

app, err := utron.NewMVC("config")

`

Hi there,

This PR is to provide caching functionality out of the box (a cache package). As it stands at the moment the supported stores are Redis, Memcache, and map (local). This would allow for using any store interchangeably without having to change code. The api is very simple to use and rather complete, it allows for the use of tags and it also provides the ability to cache any given type of struct. In addition the code is rather extendible, if we were to add more stores we would just need to comply with the given interfaces and make the tests pass for the given store. I believe the framework could benefit of something like this given to the fact that caching is a major component for any type of application and it keeps the framework lightweight (I would say it makes it even more lightweight, decreasing calls to the db). I appreciate you taking the time to review this PR and I think what you are doing with utron is great. Please let me know your thoughts and have a nice day.

Alejandro

All public methods in controllers are mapped to url path by default.

Maybe will be better if only methods with suffix or prefix "Action" will mapped by default. Some people can`t knew that their methods open for public.

Example:

// this will be parsed to /todo/home by default. Method for routing
func (t *Todo) ActionHome() {
	todos := []models.Todo{}
	....
	t.HTML(http.StatusOK)
}

// this won`t be parsed by default. Simple public method
func (t *Todo) Home2() {
	todos := []models.Todo{}
	....
	t.HTML(http.StatusOK)
}

if user want to set path manual then he can set

func NewTodo() controller.Controller {
	return &Todo{
		Routes: []string{
			"get;/;Home",			
		},
	}
}

Or maybe add some flexible settings for do it.

default parsing here https://github.com/gernest/utron/blob/master/router/routes.go#L230