rebirth

KO | EN

gitlite — search

#hacktoberfest #react #ai #typescript #llm #golang #android #machine-learning #java #kubernetes #pytorch #security #ios #mcp

(★ 69)

Supports live reloading for Go

파일 탐색기

최종 버전 다운로드 (.zip)

- - go.yml
- - main.go
  - rebirth.yml
- - docker-compose.yml
  - main.go
  - rebirth.yml
- - rebirth.yml
- - main.go
- - error.go
.gitignore
command.go
config.go
go.mod
go.sum
gomod.go
LICENSE
path.go
README.md
reloader.go
watcher.go

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# rebirth [![Actions Status](https://github.com/goccy/rebirth/workflows/Go/badge.svg)](https://github.com/goccy/rebirth/actions)
Supports live reloading for Go

![go_rebirth](https://user-images.githubusercontent.com/209884/71393497-2ba9aa00-2650-11ea-90ca-5c6b1dd0df7e.png)

# Features

- Better features than github.com/pilu/fresh
- Supports cross compile and live reloading on host OS for `docker` users ( **Very Fast** for `Docker for Mac` user )
- Supports cross compile by cgo ( C/C++ ) ( currently, works on macOS ( and target architecture is `amd64` ) only )
- Supports helper commands for `go run` `go test` `go build`

# Synopsis

## Settings

`rebirth` needs configuration file ( `rebirth.yml` ) to running .
`rebirth init` create it .

`rebirth.yml` example is the following.

```yaml
task:
  migrate:
    desc: migrate schema
    commands:
      - mysql ....
host:
  docker: container_name
build:
  main: path/to/main.go # change path to main package ( default: . )
  init:
    - echo 'init hook' # called once at starting
  before:
    - echo 'before hook' # called before build
  after:
    - echo 'after hook' # called after build
  env:
    CGO_LDFLAGS: /usr/local/lib/libz.a
run:
  env:
    RUNTIME_ENV: "fuga"
watch:
  root: . # root directory for watching ( default: . )
  ignore:
    - vendor
```

- `task` : define custom command
- `host` : specify host information for running to an application ( currently, supports `docker` only )
- `build` : specify ENV variables for building
- `run` : specify ENV variables for running
- `watch` : specify `root` directory or `ignore` directories for watching go file

## In case of running on localhost

### 1. Install `rebirth` CLI

```bash
$ GO111MODULE=on go get -u github.com/goccy/rebirth/cmd/rebirth
```

### 2. Create `rebirth.yml`

```bash
$ rebirth init
```

### 3. Run `rebirth`

```bash
rebirth
```

## In case of running with Docker for Mac

Example tree

```
.
├── docker-compose.yml
├── main.go
└── rebirth.yml
```

`main.go` is your web application's source.

### 1. Install `rebirth` CLI

```bash
$ GO111MODULE=on go get -u github.com/goccy/rebirth/cmd/rebirth
```

### 2. Install cross compiler for cgo

```bash
$ brew install FiloSottile/musl-cross/musl-cross
```

### 3. Write settings

### docker-compose.yml

```yaml
version: '2'
services:
  app:
    image: golang:1.13.5
    container_name: rebirth_app
    volumes:
      - '.:/go/src/app'
    working_dir: /go/src/app
    environment:
      GO111MODULE: "on"
    command: |
      tail -f /dev/null
```

### rebirth.yml

```yaml
host:
  docker: rebirth_app # container_name in docker-compose.yml
```

### 4. Run `rebirth`

```bash
$ rebirth

# start live reloading !!

# build for docker container's architecture on macOS (e.g. GOOS=linux GOARCH=amd64
# execute built binary on target container
```

## Helper commands

```bash
Usage:
  rebirth [OPTIONS] <command>

Help Options:
  -h, --help  Show this help message

Available commands:
  build  execute 'go build' command
  init   create rebirth.yml for configuration
  run    execute 'go run'   command
  test   execute 'go test'  command
```

### `rebirth build`

Help cross compile your go script

```bash
$ rebirth build -o app script/hoge.go
```

### `rebirth test`

Help cross compile for `go test`

```bash
$ rebirth test -v ./ -run Hoge
```

### `rebirth run`

Help cross compile for `go run`

```bash
$ rebirth run script/hoge.go
```

# How it Works

`~/work/app` directory is mounted on the container as `/go/src/app`

1. install `rebirth` CLI ( `GO111MODULE=on go get -u github.com/goccy/rebirth/cmd/rebirth` )
2. run `rebirth` and it cross compile myself for Linux ( GOOS=linux, GOARCH=amd64 ) and put it to `.rebirth` directory as `__rebirth`
3. copy `.rebirth/__rebirth` to the container ( `.rebirth` directory is mounted on the container )
4. watch `main.go` ( by [fsnotify](https://github.com/fsnotify/fsnotify) )

5. cross compile `main.go` for Linux and put to `.rebirth` directory as `program`
6. copy `.rebirth/program` to the container

7. run `__rebirth` on the container
8. `__rebirth` executes `program` 
9. edit `main.go`
10. `rebirth` detects file changed event

11. cross compile `main.go` for Linux and put to `.rebirth` directory as `program`
12. copy `.rebirth/program` to the container
13. `rebirth` send signal to `__rebirth` for reloading ( `SIGHUP` )
14. `__rebirth` kill the current application and execute `program` as a new application

# License

MIT

rebirth

파일 탐색기

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

rebirth

파일 탐색기

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README