revert README.md

absences
William Perron 1 year ago
parent aaf569cb69
commit e9632dfaae
Signed by: wperron
GPG Key ID: BFDB4EF72D73C5F2

@ -1,190 +1,170 @@
[![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/golang-migrate/migrate/ci.yaml?branch=master)](https://github.com/golang-migrate/migrate/actions/workflows/ci.yaml?query=branch%3Amaster) # themis
[![GoDoc](https://pkg.go.dev/badge/github.com/golang-migrate/migrate)](https://pkg.go.dev/github.com/golang-migrate/migrate/v4)
[![Coverage Status](https://img.shields.io/coveralls/github/golang-migrate/migrate/master.svg)](https://coveralls.io/github/golang-migrate/migrate?branch=master) Discord App to allow EU4 players to take claims on regions and provinces.
[![packagecloud.io](https://img.shields.io/badge/deb-packagecloud.io-844fec.svg)](https://packagecloud.io/golang-migrate/migrate?filter=debs)
[![Docker Pulls](https://img.shields.io/docker/pulls/migrate/migrate.svg)](https://hub.docker.com/r/migrate/migrate/) ## Setup
![Supported Go Versions](https://img.shields.io/badge/Go-1.19%2C%201.20-lightgrey.svg)
[![GitHub Release](https://img.shields.io/github/release/golang-migrate/migrate.svg)](https://github.com/golang-migrate/migrate/releases) ### Requirements
[![Go Report Card](https://goreportcard.com/badge/github.com/golang-migrate/migrate/v4)](https://goreportcard.com/report/github.com/golang-migrate/migrate/v4)
To develop:
# migrate - [Go](https://go.dev/) version 1.19 or higher installed locally
- `sqlite3` installed locally (already ships by default on most OSes)
__Database migrations written in Go. Use as [CLI](#cli-usage) or import as [library](#use-in-your-go-project).__
To deploy:
* Migrate reads migrations from [sources](#migration-sources) - Register for a [free account on Fly](https://fly.io)
and applies them in correct order to a [database](#databases). - An [AWS account](https://console.aws.amazon.com)
* Drivers are "dumb", migrate glues everything together and makes sure the logic is bulletproof.
(Keeps the drivers lightweight, too.) ### Steps
* Database drivers don't assume things or try to correct user input. When in doubt, fail.
To work with the core modules that simply interact with the database, or make
Forked from [mattes/migrate](https://github.com/mattes/migrate) sure that everything compiles correctly, you can run the following commands:
## Databases
Database drivers run migrations. [Add a new database?](database/driver.go)
* [PostgreSQL](database/postgres)
* [PGX v4](database/pgx)
* [PGX v5](database/pgx/v5)
* [Redshift](database/redshift)
* [Ql](database/ql)
* [Cassandra](database/cassandra)
* [SQLite](database/sqlite)
* [SQLite3](database/sqlite3) ([todo #165](https://github.com/mattes/migrate/issues/165))
* [SQLCipher](database/sqlcipher)
* [MySQL/ MariaDB](database/mysql)
* [Neo4j](database/neo4j)
* [MongoDB](database/mongodb)
* [CrateDB](database/crate) ([todo #170](https://github.com/mattes/migrate/issues/170))
* [Shell](database/shell) ([todo #171](https://github.com/mattes/migrate/issues/171))
* [Google Cloud Spanner](database/spanner)
* [CockroachDB](database/cockroachdb)
* [YugabyteDB](database/yugabytedb)
* [ClickHouse](database/clickhouse)
* [Firebird](database/firebird)
* [MS SQL Server](database/sqlserver)
### Database URLs
Database connection strings are specified via URLs. The URL format is driver dependent but generally has the form: `dbdriver://username:password@host:port/dbname?param1=true&param2=false`
Any [reserved URL characters](https://en.wikipedia.org/wiki/Percent-encoding#Percent-encoding_reserved_characters) need to be escaped. Note, the `%` character also [needs to be escaped](https://en.wikipedia.org/wiki/Percent-encoding#Percent-encoding_the_percent_character)
Explicitly, the following characters need to be escaped:
`!`, `#`, `$`, `%`, `&`, `'`, `(`, `)`, `*`, `+`, `,`, `/`, `:`, `;`, `=`, `?`, `@`, `[`, `]`
It's easiest to always run the URL parts of your DB connection URL (e.g. username, password, etc) through an URL encoder. See the example Python snippets below:
```bash ```bash
$ python3 -c 'import urllib.parse; print(urllib.parse.quote(input("String to encode: "), ""))' go test ./...
String to encode: FAKEpassword!#$%&'()*+,/:;=?@[] go build -o ./bin/ ./cmd/...
FAKEpassword%21%23%24%25%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D
$ python2 -c 'import urllib; print urllib.quote(raw_input("String to encode: "), "")'
String to encode: FAKEpassword!#$%&'()*+,/:;=?@[]
FAKEpassword%21%23%24%25%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D
$
``` ```
## Migration Sources ## Operations
Source drivers read migrations from local or remote sources. [Add a new source?](source/driver.go) This application is deployed via [Fly](https://fly.io) on a single virtual
machine instance. It uses an embed SQLite database as its database engine, and
uses [Litestream](https://litestream.io) to replicate the database to an S3
bucket.
* [Filesystem](source/file) - read from filesystem ### Application Configuration
* [io/fs](source/iofs) - read from a Go [io/fs](https://pkg.go.dev/io/fs#FS)
* [Go-Bindata](source/go_bindata) - read from embedded binary data ([jteeuwen/go-bindata](https://github.com/jteeuwen/go-bindata))
* [pkger](source/pkger) - read from embedded binary data ([markbates/pkger](https://github.com/markbates/pkger))
* [GitHub](source/github) - read from remote GitHub repositories
* [GitHub Enterprise](source/github_ee) - read from remote GitHub Enterprise repositories
* [Bitbucket](source/bitbucket) - read from remote Bitbucket repositories
* [Gitlab](source/gitlab) - read from remote Gitlab repositories
* [AWS S3](source/aws_s3) - read from Amazon Web Services S3
* [Google Cloud Storage](source/google_cloud_storage) - read from Google Cloud Platform Storage
## CLI usage The deployment configurations can be found in the [fly.toml](/fly.toml) file and
you can find more information on the configuration options [in the official Fly
documentation](https://fly.io/docs/reference/configuration/).
* Simple wrapper around this library. The virtual image is based off of the [Dockerfile](/Dockerfile) which is a
* Handles ctrl+c (SIGINT) gracefully. multi-stage build that builds the main application binary, downloads Litestream
* No config search paths, no config files, no magic ENV var injections. and packages everything on top of an Ubuntu 22.04 base.
__[CLI Documentation](cmd/migrate)__ ### Entrypoint
### Basic usage The application is started using a [custom entrypoint shell script](/start.sh)
that is in charge of first restoring the database file through Litestream and
then starting the main application as a [child process of Litestream's
replication process](https://litestream.io/reference/replicate/#arguments).
```bash It's a very simple script but is necessary since the application doesn't have a
$ migrate -source file://path/to/migrations -database postgres://localhost:5432/database up 2 persistent volume to rely on and must rehydrate its database file after every
``` deployment.
### Docker usage ### Environment Variables
```bash | Env Var | Defined At |
$ docker run -v {{ migration dir }}:/migrations --network host migrate/migrate | ----------------------- | --------------------- |
-path=/migrations/ -database postgres://localhost:5432/database up 2 | `DISCORD_TOKEN` | fly secret |
``` | `DISCORD_APP_ID` | [fly.toml](/fly.toml) |
| `DISCORD_GUILD_ID` | [fly.toml](fly.toml) |
| `AWS_ACCESS_KEY_ID` | fly secret |
| `AWS_SECRET_ACCESS_KEY` | fly secret |
## Use in your Go project ## Local Development
* API is stable and frozen for this release (v3 & v4).
* Uses [Go modules](https://golang.org/cmd/go/#hdr-Modules__module_versions__and_more) to manage dependencies.
* To help prevent database corruptions, it supports graceful stops via `GracefulStop chan bool`.
* Bring your own logger.
* Uses `io.Reader` streams internally for low memory overhead.
* Thread-safe and no goroutine leaks.
__[Go Documentation](https://pkg.go.dev/github.com/golang-migrate/migrate/v4)__
```go
import (
"github.com/golang-migrate/migrate/v4"
_ "github.com/golang-migrate/migrate/v4/database/postgres"
_ "github.com/golang-migrate/migrate/v4/source/github"
)
func main() {
m, err := migrate.New(
"github://mattes:personal-access-token@mattes/migrate_test",
"postgres://localhost:5432/database?sslmode=enable")
m.Steps(2)
}
```
Want to use an existing database client? ### Application Entrypoint
```go
import (
"database/sql"
_ "github.com/lib/pq"
"github.com/golang-migrate/migrate/v4"
"github.com/golang-migrate/migrate/v4/database/postgres"
_ "github.com/golang-migrate/migrate/v4/source/file"
)
func main() {
db, err := sql.Open("postgres", "postgres://localhost:5432/database?sslmode=enable")
driver, err := postgres.WithInstance(db, &postgres.Config{})
m, err := migrate.NewWithDatabaseInstance(
"file:///migrations",
"postgres", driver)
m.Up() // or m.Step(2) if you want to explicitly set the number of migrations to run
}
```
## Getting started - `./cmd/themis-server` This is the main application entrypoint
- `./cmd/themis-repl` _coming soon_
Go to [getting started](GETTING_STARTED.md) ### Core Functions
## Tutorials The core database functions can be developed and tested locally easily, just run
`go test ./...` to test your changes locally.
* [CockroachDB](database/cockroachdb/TUTORIAL.md) You can also load a test database easily by using the `init.sql` script. You can
* [PostgreSQL](database/postgres/TUTORIAL.md) use the cli sqlite3 client or connect using whatever SQL editor you prefer that
can open sqlite3 connections.
(more tutorials to come) ```bash
sqlite3 local.db < migrations/init.sql
sqlite3 local.db
# interactive SQLite session
```
## Migration files ### Discord Integration
Each migration has an up and down migration. [Why?](FAQ.md#why-two-separate-files-up-and-down-for-a-migration) This is a work in progress, but I am currently using a dedicated Discord server
with this application already signed into it. You can contact me directly to be
invited into that server. From there you only need to set the following
environment variables before launching the `./cmd/themis-server` entrypoint:
```bash ```bash
1481574547_create_users_table.up.sql export DISCORD_APP_ID="1014881815921705030"
1481574547_create_users_table.down.sql export DISCORD_GUILD_ID="[test server id goes here]"
``` ```
[Best practices: How to write migrations.](MIGRATIONS.md) ### Litestream replication
Litestream is _not a necessary component_ to run the `./cmd/themis-server`
entrypoint and can be safely ignored when developing locally. Still, if you wish
to try it out, you can find the Litestream commands used in production in the
[start.sh](/start.sh) script. As per the Litestream docs, it should work fine
with [Minio](https://min.io/) but I have not tested it yet nor are there any
scripts provided to run it (yet).
## SQLite
### Importing From CSV
This is a neat feature built-in to SQLite. Using the source file at
[data/eu4-provinces.csv](/data/eu4-provinces.csv) you can import the data
directly into a SQLite database using the following command:
## Versions ```bash
$ sqlite3
# ...
sqlite> .mode csv
sqlite> .import data/eu4-provinces.csv provinces
sqlite> .schema provinces
CREATE TABLE provinces(
"ID" TEXT,
"Name" TEXT,
"Development" TEXT,
"BT" TEXT,
"BP" TEXT,
"BM" TEXT,
"Trade good" TEXT,
"Trade node" TEXT,
"Modifiers" TEXT,
"Type" TEXT,
"Continent" TEXT,
"Superregion" TEXT,
"Region" TEXT,
"Area" TEXT
);
sqlite> select count(1) from provinces;
3925
```
### Creating an SQL Dump From Imported Data
Version | Supported? | Import | Notes The init script at [migrations/init.sql](/migrations/init.sql) was initially
--------|------------|--------|------ created after importing the CSV data and running the following commands:
**master** | :white_check_mark: | `import "github.com/golang-migrate/migrate/v4"` | New features and bug fixes arrive here first |
**v4** | :white_check_mark: | `import "github.com/golang-migrate/migrate/v4"` | Used for stable releases |
**v3** | :x: | `import "github.com/golang-migrate/migrate"` (with package manager) or `import "gopkg.in/golang-migrate/migrate.v3"` (not recommended) | **DO NOT USE** - No longer supported |
## Development and Contributing ```bash
# In the same SQlite session as last section
sqlite> .output dump.sql
sqlite> .dump
```
Yes, please! [`Makefile`](Makefile) is your friend, Note: The column names were _edited manually_ to remove capital letters and
read the [development guide](CONTRIBUTING.md). spaces to make it easier to work with.
Also have a look at the [FAQ](FAQ.md). ### Claims Schema
--- ```sql
CREATE TABLE claim_types (
claim_type TEXT PRIMARY KEY
);
Looking for alternatives? [https://awesome-go.com/#database](https://awesome-go.com/#database). CREATE TABLE claims (
id INTEGER PRIMARY KEY AUTOINCREMENT,
player TEXT,
claim_type TEXT,
val TEXT,
FOREIGN KEY(claim_type) REFERENCES claim_types(claim_type)
);
```

Loading…
Cancel
Save