forked from vieter-v/vieter
Started logging stuff; added vweb source code
parent
12aff4ff9f
commit
1967f395f1
|
@ -4,3 +4,5 @@ vieter/vieter
|
|||
|
||||
# Ignore testing files
|
||||
*.pkg*
|
||||
|
||||
vieter.log
|
||||
|
|
2
Makefile
2
Makefile
|
@ -1,6 +1,6 @@
|
|||
.PHONY: run
|
||||
run:
|
||||
API_KEY=test REPO_DIR=data v watch run vieter
|
||||
API_KEY=test REPO_DIR=data LOG_LEVEL=DEBUG v watch run vieter
|
||||
|
||||
.PHONY: fmt
|
||||
fmt:
|
||||
|
|
|
@ -2,13 +2,15 @@ module main
|
|||
|
||||
import vweb
|
||||
import os
|
||||
import log
|
||||
|
||||
const port = 8000
|
||||
|
||||
struct App {
|
||||
vweb.Context
|
||||
api_key string [required]
|
||||
repo_dir string [required]
|
||||
api_key string [required; vweb_global]
|
||||
repo_dir string [required; vweb_global]
|
||||
logger log.Log [required; vweb_global]
|
||||
}
|
||||
|
||||
[noreturn]
|
||||
|
@ -17,21 +19,54 @@ fn exit_with_message(code int, msg string) {
|
|||
exit(code)
|
||||
}
|
||||
|
||||
[put; '/pkgs/:filename']
|
||||
[post; '/publish']
|
||||
fn (mut app App) put_package(filename string) vweb.Result {
|
||||
os.write_file('$app.repo_dir/$filename', app.req.data) or {
|
||||
return app.text(err.msg)
|
||||
for _, files in app.files {
|
||||
for file in files {
|
||||
filepath := os.join_path_single(app.repo_dir, file.filename)
|
||||
|
||||
if os.exists(filepath) {
|
||||
return app.text('File already exists.')
|
||||
}
|
||||
|
||||
os.write_file(filepath, file.data) or {
|
||||
return app.text('Failed to upload file.')
|
||||
}
|
||||
|
||||
return app.text('yeet')
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return app.text('done')
|
||||
}
|
||||
|
||||
fn main() {
|
||||
// Configure logger
|
||||
log_level_str := os.getenv_opt('LOG_LEVEL') or { 'WARN' }
|
||||
log_level := log.level_from_tag(log_level_str) or {
|
||||
exit_with_message(1, 'Invalid log level. The allowed values are FATAL, ERROR, WARN, INFO & DEBUG.') }
|
||||
log_file := os.getenv_opt('LOG_FILE') or { 'vieter.log' }
|
||||
|
||||
mut logger := log.Log{
|
||||
level: log_level
|
||||
}
|
||||
logger.set_full_logpath(log_file)
|
||||
logger.log_to_console_too()
|
||||
defer {
|
||||
logger.info('Flushing log file')
|
||||
logger.flush()
|
||||
logger.close()
|
||||
}
|
||||
// logger.set
|
||||
logger.info('Logger set up.')
|
||||
logger.flush()
|
||||
|
||||
// Configure vweb server
|
||||
key := os.getenv_opt('API_KEY') or { exit_with_message(1, 'No API key was provided.') }
|
||||
repo_dir := os.getenv_opt('REPO_DIR') or {
|
||||
exit_with_message(1, 'No repo directory was configured.')
|
||||
}
|
||||
println(repo_dir)
|
||||
|
||||
// We create the upload directory during startup
|
||||
if !os.is_dir(repo_dir) {
|
||||
|
@ -41,7 +76,8 @@ fn main() {
|
|||
}
|
||||
|
||||
vweb.run(&App{
|
||||
api_key: key
|
||||
repo_dir: repo_dir
|
||||
api_key: key,
|
||||
repo_dir: repo_dir,
|
||||
logger: logger
|
||||
}, port)
|
||||
}
|
||||
|
|
|
@ -0,0 +1,141 @@
|
|||
# vweb - the V Web Server #
|
||||
|
||||
A simple yet powerful web server with built-in routing, parameter handling,
|
||||
templating, and other features.
|
||||
|
||||
## Alpha level software ##
|
||||
|
||||
Some features may not be complete, and there may still be bugs. However, it is
|
||||
still a very useful tool. The [gitly](https://gitly.org/) site is based on vweb.
|
||||
|
||||
## Features ##
|
||||
|
||||
- **Very fast** performance of C on the web.
|
||||
- **Small binary** hello world website is <100 KB.
|
||||
- **Easy to deploy** just one binary file that also includes all templates.
|
||||
No need to install any dependencies.
|
||||
- **Templates are precompiled** all errors are visible at compilation time,
|
||||
not at runtime.
|
||||
|
||||
There is no formal documentation yet - here is a simple
|
||||
[example](https://github.com/vlang/v/tree/master/examples/vweb/vweb_example.v)
|
||||
|
||||
There's also the V forum, [vorum](https://github.com/vlang/vorum)
|
||||
|
||||
`vorum.v` contains all GET and POST actions.
|
||||
|
||||
```v ignore
|
||||
pub fn (app mut App) index() {
|
||||
posts := app.find_all_posts()
|
||||
$vweb.html()
|
||||
}
|
||||
|
||||
// TODO ['/post/:id/:title']
|
||||
// TODO `fn (app App) post(id int)`
|
||||
pub fn (app App) post() {
|
||||
id := app.get_post_id()
|
||||
post := app.retrieve_post(id) or {
|
||||
app.redirect('/')
|
||||
return
|
||||
}
|
||||
comments := app.find_comments(id)
|
||||
show_form := true
|
||||
$vweb.html()
|
||||
}
|
||||
```
|
||||
|
||||
`index.html` is an example of the V template language:
|
||||
|
||||
```html
|
||||
@for post in posts
|
||||
<div class=post>
|
||||
<a class=topic href="@post.url">@post.title</a>
|
||||
<img class=comment-img>
|
||||
<span class=nr-comments>@post.nr_comments</span>
|
||||
<span class=time>@post.time</span>
|
||||
</div>
|
||||
@end
|
||||
```
|
||||
|
||||
`$vweb.html()` compiles an HTML template into V during compilation,
|
||||
and embeds the resulting code into the current action.
|
||||
|
||||
That means that the template automatically has access to that action's entire environment.
|
||||
|
||||
## Deploying vweb apps ##
|
||||
|
||||
Everything, including HTML templates, is in one binary file. That's all you need to deploy.
|
||||
|
||||
## Getting Started ##
|
||||
|
||||
To start with vweb, you have to import the module `vweb`. After the import,
|
||||
define a struct to hold vweb.Context (and any other variables your program will
|
||||
need).
|
||||
|
||||
The web server can be started by calling `vweb.run(&App{}, port)`.
|
||||
|
||||
**Example:**
|
||||
|
||||
```v ignore
|
||||
import vweb
|
||||
|
||||
struct App {
|
||||
vweb.Context
|
||||
}
|
||||
|
||||
fn main() {
|
||||
vweb.run(&App{}, 8080)
|
||||
}
|
||||
```
|
||||
|
||||
### Defining endpoints ###
|
||||
|
||||
To add endpoints to your web server, you have to extend the `App` struct.
|
||||
For routing you can either use auto-mapping of function names or specify the path as an attribute.
|
||||
The function expects a response of the type `vweb.Result`.
|
||||
|
||||
**Example:**
|
||||
|
||||
```v ignore
|
||||
// This endpoint can be accessed via http://localhost:port/hello
|
||||
fn (mut app App) hello() vweb.Result {
|
||||
return app.text('Hello')
|
||||
}
|
||||
|
||||
// This endpoint can be accessed via http://localhost:port/foo
|
||||
["/foo"]
|
||||
fn (mut app App) world() vweb.Result {
|
||||
return app.text('World')
|
||||
}
|
||||
```
|
||||
|
||||
To create an HTTP POST endpoint, you simply add a `[post]` attribute before the function definition.
|
||||
|
||||
**Example:**
|
||||
|
||||
```v ignore
|
||||
[post]
|
||||
fn (mut app App) world() vweb.Result {
|
||||
return app.text('World')
|
||||
}
|
||||
```
|
||||
|
||||
To pass a parameter to an endpoint, you simply define it inside
|
||||
an attribute, e. g. `['/hello/:user]`.
|
||||
After it is defined in the attribute, you have to add it as a function parameter.
|
||||
|
||||
**Example:**
|
||||
|
||||
```v ignore
|
||||
['/hello/:user']
|
||||
fn (mut app App) hello_user(user string) vweb.Result {
|
||||
return app.text('Hello $user')
|
||||
}
|
||||
```
|
||||
|
||||
You have access to the raw request data such as headers
|
||||
or the request body by accessing `app` (which is `vweb.Context`).
|
||||
If you want to read the request body, you can do that by calling `app.req.data`.
|
||||
To read the request headers, you just call `app.req.header` and access the
|
||||
header you want, e.g. `app.req.header.get(.content_type)`. See `struct Header`
|
||||
for all available methods (`v doc net.http Header`).
|
|
@ -0,0 +1,201 @@
|
|||
module assets
|
||||
|
||||
// this module provides an AssetManager for combining
|
||||
// and caching javascript & css.
|
||||
import os
|
||||
import time
|
||||
import crypto.md5
|
||||
|
||||
const (
|
||||
unknown_asset_type_error = 'vweb.assets: unknown asset type'
|
||||
)
|
||||
|
||||
struct AssetManager {
|
||||
mut:
|
||||
css []Asset
|
||||
js []Asset
|
||||
pub mut:
|
||||
// when true assets will be minified
|
||||
minify bool
|
||||
// the directory to store the cached/combined files
|
||||
cache_dir string
|
||||
}
|
||||
|
||||
struct Asset {
|
||||
file_path string
|
||||
last_modified time.Time
|
||||
}
|
||||
|
||||
// new_manager returns a new AssetManager
|
||||
pub fn new_manager() &AssetManager {
|
||||
return &AssetManager{}
|
||||
}
|
||||
|
||||
// add_css adds a css asset
|
||||
pub fn (mut am AssetManager) add_css(file string) bool {
|
||||
return am.add('css', file)
|
||||
}
|
||||
|
||||
// add_js adds a js asset
|
||||
pub fn (mut am AssetManager) add_js(file string) bool {
|
||||
return am.add('js', file)
|
||||
}
|
||||
|
||||
// combine_css returns the combined css as a string when to_file is false
|
||||
// when to_file is true it combines the css to disk and returns the path of the file
|
||||
pub fn (am AssetManager) combine_css(to_file bool) string {
|
||||
return am.combine('css', to_file)
|
||||
}
|
||||
|
||||
// combine_js returns the combined js as a string when to_file is false
|
||||
// when to_file is true it combines the css to disk and returns the path of the file
|
||||
pub fn (am AssetManager) combine_js(to_file bool) string {
|
||||
return am.combine('js', to_file)
|
||||
}
|
||||
|
||||
// include_css returns the html <link> tag(s) for including the css files in a page.
|
||||
// when combine is true the files are combined.
|
||||
pub fn (am AssetManager) include_css(combine bool) string {
|
||||
return am.include('css', combine)
|
||||
}
|
||||
|
||||
// include_js returns the html <script> tag(s) for including the js files in a page.
|
||||
// when combine is true the files are combined.
|
||||
pub fn (am AssetManager) include_js(combine bool) string {
|
||||
return am.include('js', combine)
|
||||
}
|
||||
|
||||
fn (am AssetManager) combine(asset_type string, to_file bool) string {
|
||||
if am.cache_dir == '' {
|
||||
panic('vweb.assets: you must set a cache dir.')
|
||||
}
|
||||
cache_key := am.get_cache_key(asset_type)
|
||||
out_file := '$am.cache_dir/${cache_key}.$asset_type'
|
||||
mut out := ''
|
||||
// use cache
|
||||
if os.exists(out_file) {
|
||||
if to_file {
|
||||
return out_file
|
||||
}
|
||||
cached := os.read_file(out_file) or { return '' }
|
||||
return cached
|
||||
}
|
||||
// rebuild
|
||||
for asset in am.get_assets(asset_type) {
|
||||
data := os.read_file(asset.file_path) or { return '' }
|
||||
out += data
|
||||
}
|
||||
if am.minify {
|
||||
if asset_type == 'css' {
|
||||
out = minify_css(out)
|
||||
} else {
|
||||
out = minify_js(out)
|
||||
}
|
||||
}
|
||||
if !to_file {
|
||||
return out
|
||||
}
|
||||
if !os.is_dir(am.cache_dir) {
|
||||
os.mkdir(am.cache_dir) or { panic(err) }
|
||||
}
|
||||
mut file := os.create(out_file) or { panic(err) }
|
||||
file.write(out.bytes()) or { panic(err) }
|
||||
file.close()
|
||||
return out_file
|
||||
}
|
||||
|
||||
fn (am AssetManager) get_cache_key(asset_type string) string {
|
||||
mut files_salt := ''
|
||||
mut latest_modified := i64(0)
|
||||
for asset in am.get_assets(asset_type) {
|
||||
files_salt += asset.file_path
|
||||
if asset.last_modified.unix > latest_modified {
|
||||
latest_modified = asset.last_modified.unix
|
||||
}
|
||||
}
|
||||
hash := md5.sum(files_salt.bytes()).hex()
|
||||
return '$hash-$latest_modified'
|
||||
}
|
||||
|
||||
fn (am AssetManager) include(asset_type string, combine bool) string {
|
||||
assets := am.get_assets(asset_type)
|
||||
mut out := ''
|
||||
if asset_type == 'css' {
|
||||
if combine {
|
||||
file := am.combine(asset_type, true)
|
||||
return '<link rel="stylesheet" href="$file">\n'
|
||||
}
|
||||
for asset in assets {
|
||||
out += '<link rel="stylesheet" href="$asset.file_path">\n'
|
||||
}
|
||||
}
|
||||
if asset_type == 'js' {
|
||||
if combine {
|
||||
file := am.combine(asset_type, true)
|
||||
return '<script type="text/javascript" src="$file"></script>\n'
|
||||
}
|
||||
for asset in assets {
|
||||
out += '<script type="text/javascript" src="$asset.file_path"></script>\n'
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// dont return option until size limit is removed
|
||||
// fn (mut am AssetManager) add(asset_type, file string) ?bool {
|
||||
fn (mut am AssetManager) add(asset_type string, file string) bool {
|
||||
if !os.exists(file) {
|
||||
// return error('vweb.assets: cannot add asset $file, it does not exist')
|
||||
return false
|
||||
}
|
||||
asset := Asset{
|
||||
file_path: file
|
||||
last_modified: time.Time{
|
||||
unix: os.file_last_mod_unix(file)
|
||||
}
|
||||
}
|
||||
if asset_type == 'css' {
|
||||
am.css << asset
|
||||
} else if asset_type == 'js' {
|
||||
am.js << asset
|
||||
} else {
|
||||
panic('$assets.unknown_asset_type_error ($asset_type).')
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
fn (am AssetManager) exists(asset_type string, file string) bool {
|
||||
assets := am.get_assets(asset_type)
|
||||
for asset in assets {
|
||||
if asset.file_path == file {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
fn (am AssetManager) get_assets(asset_type string) []Asset {
|
||||
if asset_type != 'css' && asset_type != 'js' {
|
||||
panic('$assets.unknown_asset_type_error ($asset_type).')
|
||||
}
|
||||
assets := if asset_type == 'css' { am.css } else { am.js }
|
||||
return assets
|
||||
}
|
||||
|
||||
// todo: implement proper minification
|
||||
pub fn minify_css(css string) string {
|
||||
mut lines := css.split('\n')
|
||||
for i, _ in lines {
|
||||
lines[i] = lines[i].trim_space()
|
||||
}
|
||||
return lines.join(' ')
|
||||
}
|
||||
|
||||
// todo: implement proper minification
|
||||
pub fn minify_js(js string) string {
|
||||
mut lines := js.split('\n')
|
||||
for i, _ in lines {
|
||||
lines[i] = lines[i].trim_space()
|
||||
}
|
||||
return lines.join(' ')
|
||||
}
|
|
@ -0,0 +1,179 @@
|
|||
import vweb.assets
|
||||
import os
|
||||
|
||||
// clean_cache_dir used before and after tests that write to a cache directory.
|
||||
// Because of parallel compilation and therefore test running,
|
||||
// unique cache dirs are needed per test function.
|
||||
fn clean_cache_dir(dir string) {
|
||||
if os.is_dir(dir) {
|
||||
os.rmdir_all(dir) or { panic(err) }
|
||||
}
|
||||
}
|
||||
|
||||
fn base_cache_dir() string {
|
||||
return os.join_path(os.temp_dir(), 'assets_test_cache')
|
||||
}
|
||||
|
||||
fn cache_dir(test_name string) string {
|
||||
return os.join_path(base_cache_dir(), test_name)
|
||||
}
|
||||
|
||||
fn get_test_file_path(file string) string {
|
||||
path := os.join_path(base_cache_dir(), file)
|
||||
if !os.is_dir(base_cache_dir()) {
|
||||
os.mkdir_all(base_cache_dir()) or { panic(err) }
|
||||
}
|
||||
if !os.exists(path) {
|
||||
os.write_file(path, get_test_file_contents(file)) or { panic(err) }
|
||||
}
|
||||
return path
|
||||
}
|
||||
|
||||
fn get_test_file_contents(file string) string {
|
||||
contents := match file {
|
||||
'test1.js' { '{"one": 1}\n' }
|
||||
'test2.js' { '{"two": 2}\n' }
|
||||
'test1.css' { '.one {\n\tcolor: #336699;\n}\n' }
|
||||
'test2.css' { '.two {\n\tcolor: #996633;\n}\n' }
|
||||
else { 'wibble\n' }
|
||||
}
|
||||
return contents
|
||||
}
|
||||
|
||||
fn test_set_cache() {
|
||||
mut am := assets.new_manager()
|
||||
am.cache_dir = 'cache'
|
||||
}
|
||||
|
||||
fn test_set_minify() {
|
||||
mut am := assets.new_manager()
|
||||
am.minify = true
|
||||
}
|
||||
|
||||
fn test_add() {
|
||||
mut am := assets.new_manager()
|
||||
assert am.add('css', 'testx.css') == false
|
||||
assert am.add('css', get_test_file_path('test1.css')) == true
|
||||
assert am.add('js', get_test_file_path('test1.js')) == true
|
||||
// assert am.add('css', get_test_file_path('test2.js')) == false // TODO: test extension on add
|
||||
}
|
||||
|
||||
fn test_add_css() {
|
||||
mut am := assets.new_manager()
|
||||
assert am.add_css('testx.css') == false
|
||||
assert am.add_css(get_test_file_path('test1.css')) == true
|
||||
// assert am.add_css(get_test_file_path('test1.js')) == false // TODO: test extension on add
|
||||
}
|
||||
|
||||
fn test_add_js() {
|
||||
mut am := assets.new_manager()
|
||||
assert am.add_js('testx.js') == false
|
||||
assert am.add_css(get_test_file_path('test1.js')) == true
|
||||
// assert am.add_css(get_test_file_path('test1.css')) == false // TODO: test extension on add
|
||||
}
|
||||
|
||||
fn test_combine_css() {
|
||||
mut am := assets.new_manager()
|
||||
am.cache_dir = cache_dir('test_combine_css')
|
||||
clean_cache_dir(am.cache_dir)
|
||||
am.add_css(get_test_file_path('test1.css'))
|
||||
am.add_css(get_test_file_path('test2.css'))
|
||||
// TODO: How do I test non-minified, is there a "here doc" format that keeps formatting?
|
||||
am.minify = true
|
||||
expected := '.one { color: #336699; } .two { color: #996633; } '
|
||||
actual := am.combine_css(false)
|
||||
assert actual == expected
|
||||
assert actual.contains(expected)
|
||||
// Test cache path doesn't change when input files and minify setting do not.
|
||||
path1 := am.combine_css(true)
|
||||
clean_cache_dir(am.cache_dir)
|
||||
path2 := am.combine_css(true)
|
||||
assert path1 == path2
|
||||
clean_cache_dir(am.cache_dir)
|
||||
}
|
||||
|
||||
fn test_combine_js() {
|
||||
mut am := assets.new_manager()
|
||||
am.cache_dir = cache_dir('test_combine_js')
|
||||
clean_cache_dir(am.cache_dir)
|
||||
am.add_js(get_test_file_path('test1.js'))
|
||||
am.add_js(get_test_file_path('test2.js'))
|
||||
expected1 := '{"one": 1}'
|
||||
expected2 := '{"two": 2}'
|
||||
expected := expected1 + '\n' + expected2 + '\n'
|
||||
actual := am.combine_js(false)
|
||||
assert actual == expected
|
||||
assert actual.contains(expected)
|
||||
assert actual.contains(expected1)
|
||||
assert actual.contains(expected2)
|
||||
am.minify = true
|
||||
clean_cache_dir(am.cache_dir)
|
||||
expected3 := expected1 + ' ' + expected2 + ' '
|
||||
actual2 := am.combine_js(false)
|
||||
assert actual2 == expected3
|
||||
assert actual2.contains(expected3)
|
||||
// Test cache path doesn't change when input files and minify setting do not.
|
||||
path1 := am.combine_js(true)
|
||||
clean_cache_dir(am.cache_dir)
|
||||
path2 := am.combine_js(true)
|
||||
assert path1 == path2
|
||||
clean_cache_dir(am.cache_dir)
|
||||
}
|
||||
|
||||
fn test_include_css() {
|
||||
mut am := assets.new_manager()
|
||||
file1 := get_test_file_path('test1.css')
|
||||
am.add_css(file1)
|
||||
expected := '<link rel="stylesheet" href="$file1">\n'
|
||||
actual := am.include_css(false)
|
||||
assert actual == expected
|
||||
assert actual.contains(expected)
|
||||
// Two lines of output.
|
||||
file2 := get_test_file_path('test2.css')
|
||||
am.add_css(file2)
|
||||
am.cache_dir = cache_dir('test_include_css')
|
||||
clean_cache_dir(am.cache_dir)
|
||||
expected2 := expected + '<link rel="stylesheet" href="$file2">\n'
|
||||
actual2 := am.include_css(false)
|
||||
assert actual2 == expected2
|
||||
assert actual2.contains(expected2)
|
||||
// Combined output.
|
||||
clean_cache_dir(am.cache_dir)
|
||||
actual3 := am.include_css(true)
|
||||
assert actual3.contains(expected2) == false
|
||||
assert actual3.starts_with('<link rel="stylesheet" href="$am.cache_dir/') == true
|
||||
// Test cache path doesn't change when input files and minify setting do not.
|
||||
clean_cache_dir(am.cache_dir)
|
||||
actual4 := am.include_css(true)
|
||||
assert actual4 == actual3
|
||||
clean_cache_dir(am.cache_dir)
|
||||
}
|
||||
|
||||
fn test_include_js() {
|
||||
mut am := assets.new_manager()
|
||||
file1 := get_test_file_path('test1.js')
|
||||
am.add_js(file1)
|
||||
expected := '<script type="text/javascript" src="$file1"></script>\n'
|
||||
actual := am.include_js(false)
|
||||
assert actual == expected
|
||||
assert actual.contains(expected)
|
||||
// Two lines of output.
|
||||
file2 := get_test_file_path('test2.js')
|
||||
am.add_js(file2)
|
||||
am.cache_dir = cache_dir('test_include_js')
|
||||
clean_cache_dir(am.cache_dir)
|
||||
expected2 := expected + '<script type="text/javascript" src="$file2"></script>\n'
|
||||
actual2 := am.include_js(false)
|
||||
assert actual2 == expected2
|
||||
assert actual2.contains(expected2)
|
||||
// Combined output.
|
||||
clean_cache_dir(am.cache_dir)
|
||||
actual3 := am.include_js(true)
|
||||
assert actual3.contains(expected2) == false
|
||||
assert actual3.starts_with('<script type="text/javascript" src="$am.cache_dir/')
|
||||
// Test cache path doesn't change when input files and minify setting do not.
|
||||
clean_cache_dir(am.cache_dir)
|
||||
actual4 := am.include_js(true)
|
||||
assert actual4 == actual3
|
||||
clean_cache_dir(am.cache_dir)
|
||||
}
|
|
@ -0,0 +1,74 @@
|
|||
module vweb
|
||||
|
||||
import net.urllib
|
||||
import net.http
|
||||
|
||||
// Parsing function attributes for methods and path.
|
||||
fn parse_attrs(name string, attrs []string) ?([]http.Method, string) {
|
||||
if attrs.len == 0 {
|
||||
return [http.Method.get], '/$name'
|
||||
}
|
||||
|
||||
mut x := attrs.clone()
|
||||
mut methods := []http.Method{}
|
||||
mut path := ''
|
||||
|
||||
for i := 0; i < x.len; {
|
||||
attr := x[i]
|
||||
attru := attr.to_upper()
|
||||
m := http.method_from_str(attru)
|
||||
if attru == 'GET' || m != .get {
|
||||
methods << m
|
||||
x.delete(i)
|
||||
continue
|
||||
}
|
||||
if attr.starts_with('/') {
|
||||
if path != '' {
|
||||
return IError(http.MultiplePathAttributesError{})
|
||||
}
|
||||
path = attr
|
||||
x.delete(i)
|
||||
continue
|
||||
}
|
||||
i++
|
||||
}
|
||||
if x.len > 0 {
|
||||
return IError(http.UnexpectedExtraAttributeError{
|
||||
msg: 'Encountered unexpected extra attributes: $x'
|
||||
})
|
||||
}
|
||||
if methods.len == 0 {
|
||||
methods = [http.Method.get]
|
||||
}
|
||||
if path == '' {
|
||||
path = '/$name'
|
||||
}
|
||||
// Make path lowercase for case-insensitive comparisons
|
||||
return methods, path.to_lower()
|
||||
}
|
||||
|
||||
fn parse_query_from_url(url urllib.URL) map[string]string {
|
||||
mut query := map[string]string{}
|
||||
for k, v in url.query().data {
|
||||
query[k] = v.data[0]
|
||||
}
|
||||
return query
|
||||
}
|
||||
|
||||
fn parse_form_from_request(request http.Request) ?(map[string]string, map[string][]http.FileData) {
|
||||
mut form := map[string]string{}
|
||||
mut files := map[string][]http.FileData{}
|
||||
if request.method in methods_with_form {
|
||||
ct := request.header.get(.content_type) or { '' }.split(';').map(it.trim_left(' \t'))
|
||||
if 'multipart/form-data' in ct {
|
||||
boundary := ct.filter(it.starts_with('boundary='))
|
||||
if boundary.len != 1 {
|
||||
return error('detected more that one form-data boundary')
|
||||
}
|
||||
form, files = http.parse_multipart_form(request.data, boundary[0][9..])
|
||||
} else {
|
||||
form = http.parse_form(request.data)
|
||||
}
|
||||
}
|
||||
return form, files
|
||||
}
|
|
@ -0,0 +1,282 @@
|
|||
module vweb
|
||||
|
||||
struct RoutePair {
|
||||
url string
|
||||
route string
|
||||
}
|
||||
|
||||
fn (rp RoutePair) test() ?[]string {
|
||||
url := rp.url.split('/').filter(it != '')
|
||||
route := rp.route.split('/').filter(it != '')
|
||||
return route_matches(url, route)
|
||||
}
|
||||
|
||||
fn (rp RoutePair) test_match() {
|
||||
rp.test() or { panic('should match: $rp') }
|
||||
}
|
||||
|
||||
fn (rp RoutePair) test_no_match() {
|
||||
rp.test() or { return }
|
||||
panic('should not match: $rp')
|
||||
}
|
||||
|
||||
fn (rp RoutePair) test_param(expected []string) {
|
||||
res := rp.test() or { panic('should match: $rp') }
|
||||
assert res == expected
|
||||
}
|
||||
|
||||
fn test_route_no_match() {
|
||||
tests := [
|
||||
RoutePair{
|
||||
url: '/a'
|
||||
route: '/a/b/c'
|
||||
},
|
||||
RoutePair{
|
||||
url: '/a/'
|
||||
route: '/a/b/c'
|
||||
},
|
||||
RoutePair{
|
||||
url: '/a/b'
|
||||
route: '/a/b/c'
|
||||
},
|
||||
RoutePair{
|
||||
url: '/a/b/'
|
||||
route: '/a/b/c'
|
||||
},
|
||||
RoutePair{
|
||||
url: '/a/c/b'
|
||||
route: '/a/b/c'
|
||||
},
|
||||
RoutePair{
|
||||
url: '/a/c/b/'
|
||||
route: '/a/b/c'
|
||||
},
|
||||
RoutePair{
|
||||
url: '/a/b/c/d'
|
||||
route: '/a/b/c'
|
||||
},
|
||||
RoutePair{
|
||||
url: '/a/b/c'
|
||||
route: '/'
|
||||
},
|
||||
]
|
||||
for test in tests {
|
||||
test.test_no_match()
|
||||
}
|
||||
}
|
||||
|
||||
fn test_route_exact_match() {
|
||||
tests := [
|
||||
RoutePair{
|
||||
url: '/a/b/c'
|
||||
route: '/a/b/c'
|
||||
},
|
||||
RoutePair{
|
||||
url: '/a/b/c/'
|
||||
route: '/a/b/c'
|
||||
},
|
||||
RoutePair{
|
||||
url: '/a'
|
||||
route: '/a'
|
||||
},
|
||||
RoutePair{
|
||||
url: '/'
|
||||
route: '/'
|
||||
},
|
||||
]
|
||||
for test in tests {
|
||||
test.test_match()
|
||||
}
|
||||
}
|
||||
|
||||
fn test_route_params_match() {
|
||||
RoutePair{
|
||||
url: '/a/b/c'
|
||||
route: '/:a/b/c'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c'
|
||||
route: '/a/:b/c'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c'
|
||||
route: '/a/b/:c'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c'
|
||||
route: '/:a/b/:c'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c'
|
||||
route: '/:a/:b/:c'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/one/two/three'
|
||||
route: '/:a/:b/:c'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/one/b/c'
|
||||
route: '/:a/b/c'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/one/two/three'
|
||||
route: '/:a/b/c'
|
||||
}.test_no_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/one/two/three'
|
||||
route: '/:a/:b/c'
|
||||
}.test_no_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/one/two/three'
|
||||
route: '/:a/b/:c'
|
||||
}.test_no_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c/d'
|
||||
route: '/:a/:b/:c'
|
||||
}.test_no_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/1/2/3/4'
|
||||
route: '/:a/:b/:c'
|
||||
}.test_no_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b'
|
||||
route: '/:a/:b/:c'
|
||||
}.test_no_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/1/2'
|
||||
route: '/:a/:b/:c'
|
||||
}.test_no_match()
|
||||
}
|
||||
|
||||
fn test_route_params() {
|
||||
RoutePair{
|
||||
url: '/a/b/c'
|
||||
route: '/:a/b/c'
|
||||
}.test_param(['a'])
|
||||
|
||||
RoutePair{
|
||||
url: '/one/b/c'
|
||||
route: '/:a/b/c'
|
||||
}.test_param(['one'])
|
||||
|
||||
RoutePair{
|
||||
url: '/one/two/c'
|
||||
route: '/:a/:b/c'
|
||||
}.test_param(['one', 'two'])
|
||||
|
||||
RoutePair{
|
||||
url: '/one/two/three'
|
||||
route: '/:a/:b/:c'
|
||||
}.test_param(['one', 'two', 'three'])
|
||||
|
||||
RoutePair{
|
||||
url: '/one/b/three'
|
||||
route: '/:a/b/:c'
|
||||
}.test_param(['one', 'three'])
|
||||
}
|
||||
|
||||
fn test_route_params_array_match() {
|
||||
// array can only be used on the last word (TODO: add parsing / tests to ensure this)
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c'
|
||||
route: '/a/b/:c...'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c/d'
|
||||
route: '/a/b/:c...'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c/d/e'
|
||||
route: '/a/b/:c...'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/one/b/c/d/e'
|
||||
route: '/:a/b/:c...'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/one/two/c/d/e'
|
||||
route: '/:a/:b/:c...'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/one/two/three/four/five'
|
||||
route: '/:a/:b/:c...'
|
||||
}.test_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b'
|
||||
route: '/:a/:b/:c...'
|
||||
}.test_no_match()
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/'
|
||||
route: '/:a/:b/:c...'
|
||||
}.test_no_match()
|
||||
}
|
||||
|
||||
fn test_route_params_array() {
|
||||
RoutePair{
|
||||
url: '/a/b/c'
|
||||
route: '/a/b/:c...'
|
||||
}.test_param(['c'])
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c/d'
|
||||
route: '/a/b/:c...'
|
||||
}.test_param(['c/d'])
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c/d/'
|
||||
route: '/a/b/:c...'
|
||||
}.test_param(['c/d'])
|
||||
|
||||
RoutePair{
|
||||
url: '/a/b/c/d/e'
|
||||
route: '/a/b/:c...'
|
||||
}.test_param(['c/d/e'])
|
||||
|
||||
RoutePair{
|
||||
url: '/one/b/c/d/e'
|
||||
route: '/:a/b/:c...'
|
||||
}.test_param(['one', 'c/d/e'])
|
||||
|
||||
RoutePair{
|
||||
url: '/one/two/c/d/e'
|
||||
route: '/:a/:b/:c...'
|
||||
}.test_param(['one', 'two', 'c/d/e'])
|
||||
|
||||
RoutePair{
|
||||
url: '/one/two/three/d/e'
|
||||
route: '/:a/:b/:c...'
|
||||
}.test_param(['one', 'two', 'three/d/e'])
|
||||
}
|
||||
|
||||
fn test_route_index_path() {
|
||||
RoutePair{
|
||||
url: '/'
|
||||
route: '/:path...'
|
||||
}.test_param(['/'])
|
||||
|
||||
RoutePair{
|
||||
url: '/foo/bar'
|
||||
route: '/:path...'
|
||||
}.test_param(['/foo/bar'])
|
||||
}
|
|
@ -0,0 +1,77 @@
|
|||
module sse
|
||||
|
||||
import net
|
||||
import time
|
||||
import strings
|
||||
|
||||
// This module implements the server side of `Server Sent Events`.
|
||||
// See https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#event_stream_format
|
||||
// as well as https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events
|
||||
// for detailed description of the protocol, and a simple web browser client example.
|
||||
//
|
||||
// > Event stream format
|
||||
// > The event stream is a simple stream of text data which must be encoded using UTF-8.
|
||||
// > Messages in the event stream are separated by a pair of newline characters.
|
||||
// > A colon as the first character of a line is in essence a comment, and is ignored.
|
||||
// > Note: The comment line can be used to prevent connections from timing out;
|
||||
// > a server can send a comment periodically to keep the connection alive.
|
||||
// >
|
||||
// > Each message consists of one or more lines of text listing the fields for that message.
|
||||
// > Each field is represented by the field name, followed by a colon, followed by the text
|
||||
// > data for that field's value.
|
||||
|
||||
[heap]
|
||||
pub struct SSEConnection {
|
||||
pub mut:
|
||||
headers map[string]string
|
||||
conn &net.TcpConn
|
||||
write_timeout time.Duration = 600 * time.second
|
||||
}
|
||||
|
||||
pub struct SSEMessage {
|
||||
id string
|
||||
event string
|
||||
data string
|
||||
retry int
|
||||
}
|
||||
|
||||
pub fn new_connection(conn &net.TcpConn) &SSEConnection {
|
||||
return &SSEConnection{
|
||||
conn: unsafe { conn }
|
||||
}
|
||||
}
|
||||
|
||||
// sse_start is used to send the start of a Server Side Event response.
|
||||
pub fn (mut sse SSEConnection) start() ? {
|
||||
sse.conn.set_write_timeout(sse.write_timeout)
|
||||
mut start_sb := strings.new_builder(512)
|
||||
start_sb.write_string('HTTP/1.1 200')
|
||||
start_sb.write_string('\r\nConnection: keep-alive')
|
||||
start_sb.write_string('\r\nCache-Control: no-cache')
|
||||
start_sb.write_string('\r\nContent-Type: text/event-stream')
|
||||
for k, v in sse.headers {
|
||||
start_sb.write_string('\r\n$k: $v')
|
||||
}
|
||||
start_sb.write_string('\r\n')
|
||||
sse.conn.write(start_sb) or { return error('could not start sse response') }
|
||||
}
|
||||
|
||||
// send_message sends a single message to the http client that listens for SSE.
|
||||
// It does not close the connection, so you can use it many times in a loop.
|
||||
pub fn (mut sse SSEConnection) send_message(message SSEMessage) ? {
|
||||
mut sb := strings.new_builder(512)
|
||||
if message.id != '' {
|
||||
sb.write_string('id: $message.id\n')
|
||||
}
|
||||
if message.event != '' {
|
||||
sb.write_string('event: $message.event\n')
|
||||
}
|
||||
if message.data != '' {
|
||||
sb.write_string('data: $message.data\n')
|
||||
}
|
||||
if message.retry != 0 {
|
||||
sb.write_string('retry: $message.retry\n')
|
||||
}
|
||||
sb.write_string('\n')
|
||||
sse.conn.write(sb) ?
|
||||
}
|
|
@ -0,0 +1,300 @@
|
|||
import os
|
||||
import time
|
||||
import json
|
||||
import net
|
||||
import net.http
|
||||
import io
|
||||
|
||||
const (
|
||||
sport = 12380
|
||||
exit_after_time = 12000 // milliseconds
|
||||
vexe = os.getenv('VEXE')
|
||||
vweb_logfile = os.getenv('VWEB_LOGFILE')
|
||||
vroot = os.dir(vexe)
|
||||
serverexe = os.join_path(os.cache_dir(), 'vweb_test_server.exe')
|
||||
tcp_r_timeout = 30 * time.second
|
||||
tcp_w_timeout = 30 * time.second
|
||||
)
|
||||
|
||||
// setup of vweb webserver
|
||||
fn testsuite_begin() {
|
||||
os.chdir(vroot) or {}
|
||||
if os.exists(serverexe) {
|
||||
os.rm(serverexe) or {}
|
||||
}
|
||||
}
|
||||
|
||||
fn test_a_simple_vweb_app_can_be_compiled() {
|
||||
// did_server_compile := os.system('$vexe -g -o $serverexe vlib/vweb/tests/vweb_test_server.v')
|
||||
// TODO: find out why it does not compile with -usecache and -g
|
||||
did_server_compile := os.system('$vexe -o $serverexe vlib/vweb/tests/vweb_test_server.v')
|
||||
assert did_server_compile == 0
|
||||
assert os.exists(serverexe)
|
||||
}
|
||||
|
||||
fn test_a_simple_vweb_app_runs_in_the_background() {
|
||||
mut suffix := ''
|
||||
$if !windows {
|
||||
suffix = ' > /dev/null &'
|
||||
}
|
||||
if vweb_logfile != '' {
|
||||
suffix = ' 2>> $vweb_logfile >> $vweb_logfile &'
|
||||
}
|
||||
server_exec_cmd := '$serverexe $sport $exit_after_time $suffix'
|
||||
$if debug_net_socket_client ? {
|
||||
eprintln('running:\n$server_exec_cmd')
|
||||
}
|
||||
$if windows {
|
||||
go os.system(server_exec_cmd)
|
||||
} $else {
|
||||
res := os.system(server_exec_cmd)
|
||||
assert res == 0
|
||||
}
|
||||
$if macos {
|
||||
time.sleep(1000 * time.millisecond)
|
||||
} $else {
|
||||
time.sleep(100 * time.millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
// web client tests follow
|
||||
fn assert_common_headers(received string) {
|
||||
assert received.starts_with('HTTP/1.1 200 OK\r\n')
|
||||
assert received.contains('Server: VWeb\r\n')
|
||||
assert received.contains('Content-Length:')
|
||||
assert received.contains('Connection: close\r\n')
|
||||
}
|
||||
|
||||
fn test_a_simple_tcp_client_can_connect_to_the_vweb_server() {
|
||||
received := simple_tcp_client(path: '/') or {
|
||||
assert err.msg == ''
|
||||
return
|
||||
}
|
||||
assert_common_headers(received)
|
||||
assert received.contains('Content-Type: text/plain')
|
||||
assert received.contains('Content-Length: 15')
|
||||
assert received.ends_with('Welcome to VWeb')
|
||||
}
|
||||
|
||||
fn test_a_simple_tcp_client_simple_route() {
|
||||
received := simple_tcp_client(path: '/simple') or {
|
||||
assert err.msg == ''
|
||||
return
|
||||
}
|
||||
assert_common_headers(received)
|
||||
assert received.contains('Content-Type: text/plain')
|
||||
assert received.contains('Content-Length: 15')
|
||||
assert received.ends_with('A simple result')
|
||||
}
|
||||
|
||||
fn test_a_simple_tcp_client_zero_content_length() {
|
||||
// tests that sending a content-length header of 0 doesn't hang on a read timeout
|
||||
watch := time.new_stopwatch(auto_start: true)
|
||||
simple_tcp_client(path: '/', headers: 'Content-Length: 0\r\n\r\n') or {
|
||||
assert err.msg == ''
|
||||
return
|
||||
}
|
||||
assert watch.elapsed() < 1 * time.second
|
||||
}
|
||||
|
||||
fn test_a_simple_tcp_client_html_page() {
|
||||
received := simple_tcp_client(path: '/html_page') or {
|
||||
assert err.msg == ''
|
||||
return
|
||||
}
|
||||
assert_common_headers(received)
|
||||
assert received.contains('Content-Type: text/html')
|
||||
assert received.ends_with('<h1>ok</h1>')
|
||||
}
|
||||
|
||||
// net.http client based tests follow:
|
||||
fn assert_common_http_headers(x http.Response) ? {
|
||||
assert x.status() == .ok
|
||||
assert x.header.get(.server) ? == 'VWeb'
|
||||
assert x.header.get(.content_length) ?.int() > 0
|
||||
assert x.header.get(.connection) ? == 'close'
|
||||
}
|
||||
|
||||
fn test_http_client_index() ? {
|
||||
x := http.get('http://127.0.0.1:$sport/') or { panic(err) }
|
||||
assert_common_http_headers(x) ?
|
||||
assert x.header.get(.content_type) ? == 'text/plain'
|
||||
assert x.text == 'Welcome to VWeb'
|
||||
}
|
||||
|
||||
fn test_http_client_404() ? {
|
||||
url_404_list := [
|
||||
'http://127.0.0.1:$sport/zxcnbnm',
|
||||
'http://127.0.0.1:$sport/JHKAJA',
|
||||
'http://127.0.0.1:$sport/unknown',
|
||||
]
|
||||
for url in url_404_list {
|
||||
res := http.get(url) or { panic(err) }
|
||||
assert res.status() == .not_found
|
||||
}
|
||||
}
|
||||
|
||||
fn test_http_client_simple() ? {
|
||||
x := http.get('http://127.0.0.1:$sport/simple') or { panic(err) }
|
||||
assert_common_http_headers(x) ?
|
||||
assert x.header.get(.content_type) ? == 'text/plain'
|
||||
assert x.text == 'A simple result'
|
||||
}
|
||||
|
||||
fn test_http_client_html_page() ? {
|
||||
x := http.get('http://127.0.0.1:$sport/html_page') or { panic(err) }
|
||||
assert_common_http_headers(x) ?
|
||||
assert x.header.get(.content_type) ? == 'text/html'
|
||||
assert x.text == '<h1>ok</h1>'
|
||||
}
|
||||
|
||||
fn test_http_client_settings_page() ? {
|
||||
x := http.get('http://127.0.0.1:$sport/bilbo/settings') or { panic(err) }
|
||||
assert_common_http_headers(x) ?
|
||||
assert x.text == 'username: bilbo'
|
||||
//
|
||||
y := http.get('http://127.0.0.1:$sport/kent/settings') or { panic(err) }
|
||||
assert_common_http_headers(y) ?
|
||||
assert y.text == 'username: kent'
|
||||
}
|
||||
|
||||
fn test_http_client_user_repo_settings_page() ? {
|
||||
x := http.get('http://127.0.0.1:$sport/bilbo/gostamp/settings') or { panic(err) }
|
||||
assert_common_http_headers(x) ?
|
||||
assert x.text == 'username: bilbo | repository: gostamp'
|
||||
//
|
||||
y := http.get('http://127.0.0.1:$sport/kent/golang/settings') or { panic(err) }
|
||||
assert_common_http_headers(y) ?
|
||||
assert y.text == 'username: kent | repository: golang'
|
||||
//
|
||||
z := http.get('http://127.0.0.1:$sport/missing/golang/settings') or { panic(err) }
|
||||
assert z.status() == .not_found
|
||||
}
|
||||
|
||||
struct User {
|
||||
name string
|
||||
age int
|
||||
}
|
||||
|
||||
fn test_http_client_json_post() ? {
|
||||
ouser := User{
|
||||
name: 'Bilbo'
|
||||
age: 123
|
||||
}
|
||||
json_for_ouser := json.encode(ouser)
|
||||
mut x := http.post_json('http://127.0.0.1:$sport/json_echo', json_for_ouser) or { panic(err) }
|
||||
$if debug_net_socket_client ? {
|
||||
eprintln('/json_echo endpoint response: $x')
|
||||
}
|
||||
assert x.header.get(.content_type) ? == 'application/json'
|
||||
assert x.text == json_for_ouser
|
||||
nuser := json.decode(User, x.text) or { User{} }
|
||||
assert '$ouser' == '$nuser'
|
||||
//
|
||||
x = http.post_json('http://127.0.0.1:$sport/json', json_for_ouser) or { panic(err) }
|
||||
$if debug_net_socket_client ? {
|
||||
eprintln('/json endpoint response: $x')
|
||||
}
|
||||
assert x.header.get(.content_type) ? == 'application/json'
|
||||
assert x.text == json_for_ouser
|
||||
nuser2 := json.decode(User, x.text) or { User{} }
|
||||
assert '$ouser' == '$nuser2'
|
||||
}
|
||||
|
||||
fn test_http_client_multipart_form_data() ? {
|
||||
boundary := '6844a625b1f0b299'
|
||||
name := 'foo'
|
||||
ct := 'multipart/form-data; boundary=$boundary'
|
||||
contents := 'baz buzz'
|
||||
data := '--$boundary\r
|
||||
Content-Disposition: form-data; name="$name"\r
|
||||
\r
|
||||
$contents\r
|
||||
--$boundary--\r
|
||||
'
|
||||
mut x := http.fetch(
|
||||
url: 'http://127.0.0.1:$sport/form_echo'
|
||||
method: .post
|
||||
header: http.new_header(
|
||||
key: .content_type
|
||||
value: ct
|
||||
)
|
||||
data: data
|
||||
) ?
|
||||
$if debug_net_socket_client ? {
|
||||
eprintln('/form_echo endpoint response: $x')
|
||||
}
|
||||
assert x.text == contents
|
||||
}
|
||||
|
||||
fn test_http_client_shutdown_does_not_work_without_a_cookie() {
|
||||
x := http.get('http://127.0.0.1:$sport/shutdown') or {
|
||||
assert err.msg == ''
|
||||
return
|
||||
}
|
||||
assert x.status() == .not_found
|
||||
assert x.text == '404 Not Found'
|
||||
}
|
||||
|
||||
fn testsuite_end() {
|
||||
// This test is guaranteed to be called last.
|
||||
// It sends a request to the server to shutdown.
|
||||
x := http.fetch(
|
||||
url: 'http://127.0.0.1:$sport/shutdown'
|
||||
method: .get
|
||||
cookies: {
|
||||
'skey': 'superman'
|
||||
}
|
||||
) or {
|
||||
assert err.msg == ''
|
||||
return
|
||||
}
|
||||
assert x.status() == .ok
|
||||
assert x.text == 'good bye'
|
||||
}
|
||||
|
||||
// utility code:
|
||||
struct SimpleTcpClientConfig {
|
||||
retries int = 20
|
||||
host string = 'static.dev'
|
||||
path string = '/'
|
||||
agent string = 'v/net.tcp.v'
|
||||
headers string = '\r\n'
|
||||
content string
|
||||
}
|
||||
|
||||
fn simple_tcp_client(config SimpleTcpClientConfig) ?string {
|
||||
mut client := &net.TcpConn(0)
|
||||
mut tries := 0
|
||||
for tries < config.retries {
|
||||
tries++
|
||||
client = net.dial_tcp('127.0.0.1:$sport') or {
|
||||
if tries > config.retries {
|
||||
return err
|
||||
}
|
||||
time.sleep(100 * time.millisecond)
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
client.set_read_timeout(tcp_r_timeout)
|
||||
client.set_write_timeout(tcp_w_timeout)
|
||||
defer {
|
||||
client.close() or {}
|
||||
}
|
||||
message := 'GET $config.path HTTP/1.1
|
||||
Host: $config.host
|
||||
User-Agent: $config.agent
|
||||
Accept: */*
|
||||
$config.headers
|
||||
$config.content'
|
||||
$if debug_net_socket_client ? {
|
||||
eprintln('sending:\n$message')
|
||||
}
|
||||
client.write(message.bytes()) ?
|
||||
read := io.read_all(reader: client) ?
|
||||
$if debug_net_socket_client ? {
|
||||
eprintln('received:\n$read')
|
||||
}
|
||||
return read.bytestr()
|
||||
}
|
|
@ -0,0 +1,118 @@
|
|||
module main
|
||||
|
||||
import os
|
||||
import vweb
|
||||
import time
|
||||
|
||||
const (
|
||||
known_users = ['bilbo', 'kent']
|
||||
)
|
||||
|
||||
struct App {
|
||||
vweb.Context
|
||||
port int
|
||||
timeout int
|
||||
global_config shared Config
|
||||
}
|
||||
|
||||
struct Config {
|
||||
max_ping int
|
||||
}
|
||||
|
||||
fn exit_after_timeout(timeout_in_ms int) {
|
||||
time.sleep(timeout_in_ms * time.millisecond)
|
||||
// eprintln('webserver is exiting ...')
|
||||
exit(0)
|
||||
}
|
||||
|
||||
fn main() {
|
||||
if os.args.len != 3 {
|
||||
panic('Usage: `vweb_test_server.exe PORT TIMEOUT_IN_MILLISECONDS`')
|
||||
}
|
||||
http_port := os.args[1].int()
|
||||
assert http_port > 0
|
||||
timeout := os.args[2].int()
|
||||
assert timeout > 0
|
||||
go exit_after_timeout(timeout)
|
||||
//
|
||||
shared config := &Config{
|
||||
max_ping: 50
|
||||
}
|
||||
app := &App{
|
||||
port: http_port
|
||||
timeout: timeout
|
||||
global_config: config
|
||||
}
|
||||
eprintln('>> webserver: started on http://127.0.0.1:$app.port/ , with maximum runtime of $app.timeout milliseconds.')
|
||||
// vweb.run<App>(mut app, http_port)
|
||||
vweb.run(app, http_port)
|
||||
}
|
||||
|
||||
// pub fn (mut app App) init_server() {
|
||||
//}
|
||||
|
||||
pub fn (mut app App) index() vweb.Result {
|
||||
assert app.global_config.max_ping == 50
|
||||
return app.text('Welcome to VWeb')
|
||||
}
|
||||
|
||||
pub fn (mut app App) simple() vweb.Result {
|
||||
return app.text('A simple result')
|
||||
}
|
||||
|
||||
pub fn (mut app App) html_page() vweb.Result {
|
||||
return app.html('<h1>ok</h1>')
|
||||
}
|
||||
|
||||
// the following serve custom routes
|
||||
['/:user/settings']
|
||||
pub fn (mut app App) settings(username string) vweb.Result {
|
||||
if username !in known_users {
|
||||
return app.not_found()
|
||||
}
|
||||
return app.html('username: $username')
|
||||
}
|
||||
|
||||
['/:user/:repo/settings']
|
||||
pub fn (mut app App) user_repo_settings(username string, repository string) vweb.Result {
|
||||
if username !in known_users {
|
||||
return app.not_found()
|
||||
}
|
||||
return app.html('username: $username | repository: $repository')
|
||||
}
|
||||
|
||||
['/json_echo'; post]
|
||||
pub fn (mut app App) json_echo() vweb.Result {
|
||||
// eprintln('>>>>> received http request at /json_echo is: $app.req')
|
||||
app.set_content_type(app.req.header.get(.content_type) or { '' })
|
||||
return app.ok(app.req.data)
|
||||
}
|
||||
|
||||
['/form_echo'; post]
|
||||
pub fn (mut app App) form_echo() vweb.Result {
|
||||
app.set_content_type(app.req.header.get(.content_type) or { '' })
|
||||
return app.ok(app.form['foo'])
|
||||
}
|
||||
|
||||
// Make sure [post] works without the path
|
||||
[post]
|
||||
pub fn (mut app App) json() vweb.Result {
|
||||
// eprintln('>>>>> received http request at /json is: $app.req')
|
||||
app.set_content_type(app.req.header.get(.content_type) or { '' })
|
||||
return app.ok(app.req.data)
|
||||
}
|
||||
|
||||
pub fn (mut app App) shutdown() vweb.Result {
|
||||
session_key := app.get_cookie('skey') or { return app.not_found() }
|
||||
if session_key != 'superman' {
|
||||
return app.not_found()
|
||||
}
|
||||
go app.gracefull_exit()
|
||||
return app.ok('good bye')
|
||||
}
|
||||
|
||||
fn (mut app App) gracefull_exit() {
|
||||
eprintln('>> webserver: gracefull_exit')
|
||||
time.sleep(100 * time.millisecond)
|
||||
exit(0)
|
||||
}
|
|
@ -0,0 +1,698 @@
|
|||
// Copyright (c) 2019-2022 Alexander Medvednikov. All rights reserved.
|
||||
// Use of this source code is governed by an MIT license
|
||||
// that can be found in the LICENSE file.
|
||||
module vweb
|
||||
|
||||
import os
|
||||
import io
|
||||
import net
|
||||
import net.http
|
||||
import net.urllib
|
||||
import time
|
||||
import json
|
||||
|
||||
// A type which don't get filtered inside templates
|
||||
pub type RawHtml = string
|
||||
|
||||
// A dummy structure that returns from routes to indicate that you actually sent something to a user
|
||||
[noinit]
|
||||
pub struct Result {}
|
||||
|
||||
pub const (
|
||||
methods_with_form = [http.Method.post, .put, .patch]
|
||||
headers_close = http.new_custom_header_from_map({
|
||||
'Server': 'VWeb'
|
||||
http.CommonHeader.connection.str(): 'close'
|
||||
}) or { panic('should never fail') }
|
||||
|
||||
http_302 = http.new_response(
|
||||
status: .found
|
||||
text: '302 Found'
|
||||
header: headers_close
|
||||
)
|
||||
http_400 = http.new_response(
|
||||
status: .bad_request
|
||||
text: '400 Bad Request'
|
||||
header: http.new_header(
|
||||
key: .content_type
|
||||
value: 'text/plain'
|
||||
).join(headers_close)
|
||||
)
|
||||
http_404 = http.new_response(
|
||||
status: .not_found
|
||||
text: '404 Not Found'
|
||||
header: http.new_header(
|
||||
key: .content_type
|
||||
value: 'text/plain'
|
||||
).join(headers_close)
|
||||
)
|
||||
http_500 = http.new_response(
|
||||
status: .internal_server_error
|
||||
text: '500 Internal Server Error'
|
||||
header: http.new_header(
|
||||
key: .content_type
|
||||
value: 'text/plain'
|
||||
).join(headers_close)
|
||||
)
|
||||
mime_types = {
|
||||
'.aac': 'audio/aac'
|
||||
'.abw': 'application/x-abiword'
|
||||
'.arc': 'application/x-freearc'
|
||||
'.avi': 'video/x-msvideo'
|
||||
'.azw': 'application/vnd.amazon.ebook'
|
||||
'.bin': 'application/octet-stream'
|
||||
'.bmp': 'image/bmp'
|
||||
'.bz': 'application/x-bzip'
|
||||
'.bz2': 'application/x-bzip2'
|
||||
'.cda': 'application/x-cdf'
|
||||
'.csh': 'application/x-csh'
|
||||
'.css': 'text/css'
|
||||
'.csv': 'text/csv'
|
||||
'.doc': 'application/msword'
|
||||
'.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
|
||||
'.eot': 'application/vnd.ms-fontobject'
|
||||
'.epub': 'application/epub+zip'
|
||||
'.gz': 'application/gzip'
|
||||
'.gif': 'image/gif'
|
||||
'.htm': 'text/html'
|
||||
'.html': 'text/html'
|
||||
'.ico': 'image/vnd.microsoft.icon'
|
||||
'.ics': 'text/calendar'
|
||||
'.jar': 'application/java-archive'
|
||||
'.jpeg': 'image/jpeg'
|
||||
'.jpg': 'image/jpeg'
|
||||
'.js': 'text/javascript'
|
||||
'.json': 'application/json'
|
||||
'.jsonld': 'application/ld+json'
|
||||
'.mid': 'audio/midi audio/x-midi'
|
||||
'.midi': 'audio/midi audio/x-midi'
|
||||
'.mjs': 'text/javascript'
|
||||
'.mp3': 'audio/mpeg'
|
||||
'.mp4': 'video/mp4'
|
||||
'.mpeg': 'video/mpeg'
|
||||
'.mpkg': 'application/vnd.apple.installer+xml'
|
||||
'.odp': 'application/vnd.oasis.opendocument.presentation'
|
||||
'.ods': 'application/vnd.oasis.opendocument.spreadsheet'
|
||||
'.odt': 'application/vnd.oasis.opendocument.text'
|
||||
'.oga': 'audio/ogg'
|
||||
'.ogv': 'video/ogg'
|
||||
'.ogx': 'application/ogg'
|
||||
'.opus': 'audio/opus'
|
||||
'.otf': 'font/otf'
|
||||
'.png': 'image/png'
|
||||
'.pdf': 'application/pdf'
|
||||
'.php': 'application/x-httpd-php'
|
||||
'.ppt': 'application/vnd.ms-powerpoint'
|
||||
'.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
|
||||
'.rar': 'application/vnd.rar'
|
||||
'.rtf': 'application/rtf'
|
||||
'.sh': 'application/x-sh'
|
||||
'.svg': 'image/svg+xml'
|
||||
'.swf': 'application/x-shockwave-flash'
|
||||
'.tar': 'application/x-tar'
|
||||
'.tif': 'image/tiff'
|
||||
'.tiff': 'image/tiff'
|
||||
'.ts': 'video/mp2t'
|
||||
'.ttf': 'font/ttf'
|
||||
'.txt': 'text/plain'
|
||||
'.vsd': 'application/vnd.visio'
|
||||
'.wav': 'audio/wav'
|
||||
'.weba': 'audio/webm'
|
||||
'.webm': 'video/webm'
|
||||
'.webp': 'image/webp'
|
||||
'.woff': 'font/woff'
|
||||
'.woff2': 'font/woff2'
|
||||
'.xhtml': 'application/xhtml+xml'
|
||||
'.xls': 'application/vnd.ms-excel'
|
||||
'.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
|
||||
'.xml': 'application/xml'
|
||||
'.xul': 'application/vnd.mozilla.xul+xml'
|
||||
'.zip': 'application/zip'
|
||||
'.3gp': 'video/3gpp'
|
||||
'.3g2': 'video/3gpp2'
|
||||
'.7z': 'application/x-7z-compressed'
|
||||
}
|
||||
max_http_post_size = 1024 * 1024
|
||||
default_port = 8080
|
||||
)
|
||||
|
||||
// The Context struct represents the Context which hold the HTTP request and response.
|
||||
// It has fields for the query, form, files.
|
||||
pub struct Context {
|
||||
mut:
|
||||
content_type string = 'text/plain'
|
||||
status string = '200 OK'
|
||||
pub:
|
||||
// HTTP Request
|
||||
req http.Request
|
||||
// TODO Response
|
||||
pub mut:
|
||||
done bool
|
||||
// time.ticks() from start of vweb connection handle.
|
||||
// You can use it to determine how much time is spent on your request.
|
||||
page_gen_start i64
|
||||
// TCP connection to client.
|
||||
// But beware, do not store it for further use, after request processing vweb will close connection.
|
||||
conn &net.TcpConn
|
||||
static_files map[string]string
|
||||
static_mime_types map[string]string
|
||||
// Map containing query params for the route.
|
||||
// Example: `http://localhost:3000/index?q=vpm&order_by=desc => { 'q': 'vpm', 'order_by': 'desc' }
|
||||
query map[string]string
|
||||
// Multipart-form fields.
|
||||
form map[string]string
|
||||
// Files from multipart-form.
|
||||
files map[string][]http.FileData
|
||||
|
||||
header http.Header // response headers
|
||||
// ? It doesn't seem to be used anywhere
|
||||
form_error string
|
||||
}
|
||||
|
||||
struct FileData {
|
||||
pub:
|
||||
filename string
|
||||
content_type string
|
||||
data string
|
||||
}
|
||||
|
||||
struct Route {
|
||||
methods []http.Method
|
||||
path string
|
||||
}
|
||||
|
||||
// Defining this method is optional.
|
||||
// This method called at server start.
|
||||
// You can use it for initializing globals.
|
||||
pub fn (ctx Context) init_server() {
|
||||
eprintln('init_server() has been deprecated, please init your web app in `fn main()`')
|
||||
}
|
||||
|
||||
// Defining this method is optional.
|
||||
// This method called before every request (aka middleware).
|
||||
// Probably you can use it for check user session cookie or add header.
|
||||
pub fn (ctx Context) before_request() {}
|
||||
|
||||
pub struct Cookie {
|
||||
name string
|
||||
value string
|
||||
expires time.Time
|
||||
secure bool
|
||||
http_only bool
|
||||
}
|
||||
|
||||
// vweb intern function
|
||||
[manualfree]
|
||||
pub fn (mut ctx Context) send_response_to_client(mimetype string, res string) bool {
|
||||
if ctx.done {
|
||||
return false
|
||||
}
|
||||
ctx.done = true
|
||||
|
||||
// build header
|
||||
header := http.new_header_from_map({
|
||||
http.CommonHeader.content_type: mimetype
|
||||
http.CommonHeader.content_length: res.len.str()
|
||||
}).join(ctx.header)
|
||||
|
||||
mut resp := http.Response{
|
||||
header: header.join(vweb.headers_close)
|
||||
text: res
|
||||
}
|
||||
resp.set_version(.v1_1)
|
||||
resp.set_status(http.status_from_int(ctx.status.int()))
|
||||
send_string(mut ctx.conn, resp.bytestr()) or { return false }
|
||||
return true
|
||||
}
|
||||
|
||||
// Response HTTP_OK with s as payload with content-type `text/html`
|
||||
pub fn (mut ctx Context) html(s string) Result {
|
||||
ctx.send_response_to_client('text/html', s)
|
||||
return Result{}
|
||||
}
|
||||
|
||||
// Response HTTP_OK with s as payload with content-type `text/plain`
|
||||
pub fn (mut ctx Context) text(s string) Result {
|
||||
ctx.send_response_to_client('text/plain', s)
|
||||
return Result{}
|
||||
}
|
||||
|
||||
// Response HTTP_OK with json_s as payload with content-type `application/json`
|
||||
pub fn (mut ctx Context) json<T>(j T) Result {
|
||||
json_s := json.encode(j)
|
||||
ctx.send_response_to_client('application/json', json_s)
|
||||
return Result{}
|
||||
}
|
||||
|
||||
// Response HTTP_OK with a pretty-printed JSON result
|
||||
pub fn (mut ctx Context) json_pretty<T>(j T) Result {
|
||||
json_s := json.encode_pretty(j)
|
||||
ctx.send_response_to_client('application/json', json_s)
|
||||
return Result{}
|
||||
}
|
||||
|
||||
// Response HTTP_OK with file as payload
|
||||
pub fn (mut ctx Context) file(f_path string) Result {
|
||||
ext := os.file_ext(f_path)
|
||||
data := os.read_file(f_path) or {
|
||||
eprint(err.msg)
|
||||
ctx.server_error(500)
|
||||
return Result{}
|
||||
}
|
||||
content_type := vweb.mime_types[ext]
|
||||
if content_type == '' {
|
||||
eprintln('no MIME type found for extension $ext')
|
||||
ctx.server_error(500)
|
||||
} else {
|
||||
ctx.send_response_to_client(content_type, data)
|
||||
}
|
||||
return Result{}
|
||||
}
|
||||
|
||||
// Response HTTP_OK with s as payload
|
||||
pub fn (mut ctx Context) ok(s string) Result {
|
||||
ctx.send_response_to_client(ctx.content_type, s)
|
||||
return Result{}
|
||||
}
|
||||
|
||||
// Response a server error
|
||||
pub fn (mut ctx Context) server_error(ecode int) Result {
|
||||
$if debug {
|
||||
eprintln('> ctx.server_error ecode: $ecode')
|
||||
}
|
||||
if ctx.done {
|
||||
return Result{}
|
||||
}
|
||||
send_string(mut ctx.conn, vweb.http_500.bytestr()) or {}
|
||||
return Result{}
|
||||
}
|
||||
|
||||
// Redirect to an url
|
||||
pub fn (mut ctx Context) redirect(url string) Result {
|
||||
if ctx.done {
|
||||
return Result{}
|
||||
}
|
||||
ctx.done = true
|
||||
mut resp := vweb.http_302
|
||||
resp.header = resp.header.join(ctx.header)
|
||||
resp.header.add(.location, url)
|
||||
send_string(mut ctx.conn, resp.bytestr()) or { return Result{} }
|
||||
return Result{}
|
||||
}
|
||||
|
||||
// Send an not_found response
|
||||
pub fn (mut ctx Context) not_found() Result {
|
||||
if ctx.done {
|
||||
return Result{}
|
||||
}
|
||||
ctx.done = true
|
||||
send_string(mut ctx.conn, vweb.http_404.bytestr()) or {}
|
||||
return Result{}
|
||||
}
|
||||
|
||||
// Sets a cookie
|
||||
pub fn (mut ctx Context) set_cookie(cookie Cookie) {
|
||||
mut cookie_data := []string{}
|
||||
mut secure := if cookie.secure { 'Secure;' } else { '' }
|
||||
secure += if cookie.http_only { ' HttpOnly' } else { ' ' }
|
||||
cookie_data << secure
|
||||
if cookie.expires.unix > 0 {
|
||||
cookie_data << 'expires=$cookie.expires.utc_string()'
|
||||
}
|
||||
data := cookie_data.join(' ')
|
||||
ctx.add_header('Set-Cookie', '$cookie.name=$cookie.value; $data')
|
||||
}
|
||||
|
||||
// Sets the response content type
|
||||
pub fn (mut ctx Context) set_content_type(typ string) {
|
||||
ctx.content_type = typ
|
||||
}
|
||||
|
||||
// Sets a cookie with a `expire_data`
|
||||
pub fn (mut ctx Context) set_cookie_with_expire_date(key string, val string, expire_date time.Time) {
|
||||
ctx.add_header('Set-Cookie', '$key=$val; Secure; HttpOnly; expires=$expire_date.utc_string()')
|
||||
}
|
||||
|
||||
// Gets a cookie by a key
|
||||
pub fn (ctx &Context) get_cookie(key string) ?string { // TODO refactor
|
||||
mut cookie_header := ctx.get_header('cookie')
|
||||
if cookie_header == '' {
|
||||
cookie_header = ctx.get_header('Cookie')
|
||||
}
|
||||
cookie_header = ' ' + cookie_header
|
||||
// println('cookie_header="$cookie_header"')
|
||||
// println(ctx.req.header)
|
||||
cookie := if cookie_header.contains(';') {
|
||||
cookie_header.find_between(' $key=', ';')
|
||||
} else {
|
||||
cookie_header.find_between(' $key=', '\r')
|
||||
}
|
||||
if cookie != '' {
|
||||
return cookie.trim_space()
|
||||
}
|
||||
return error('Cookie not found')
|
||||
}
|
||||
|
||||
// Sets the response status
|
||||
pub fn (mut ctx Context) set_status(code int, desc string) {
|
||||
if code < 100 || code > 599 {
|
||||
ctx.status = '500 Internal Server Error'
|
||||
} else {
|
||||
ctx.status = '$code $desc'
|
||||
}
|
||||
}
|
||||
|
||||
// Adds an header to the response with key and val
|
||||
pub fn (mut ctx Context) add_header(key string, val string) {
|
||||
ctx.header.add_custom(key, val) or {}
|
||||
}
|
||||
|
||||
// Returns the header data from the key
|
||||
pub fn (ctx &Context) get_header(key string) string {
|
||||
return ctx.req.header.get_custom(key) or { '' }
|
||||
}
|
||||
|
||||
interface DbInterface {
|
||||
db voidptr
|
||||
}
|
||||
|
||||
// run_app
|
||||
[manualfree]
|
||||
pub fn run<T>(global_app &T, port int) {
|
||||
println("sup neef")
|
||||
mut l := net.listen_tcp(.ip6, ':$port') or { panic('failed to listen $err.code $err') }
|
||||
|
||||
// Parsing methods attributes
|
||||
mut routes := map[string]Route{}
|
||||
$for method in T.methods {
|
||||
http_methods, route_path := parse_attrs(method.name, method.attrs) or {
|
||||
eprintln('error parsing method attributes: $err')
|
||||
return
|
||||
}
|
||||
|
||||
routes[method.name] = Route{
|
||||
methods: http_methods
|
||||
path: route_path
|
||||
}
|
||||
}
|
||||
println('[Vweb] Running app on http://localhost:$port')
|
||||
for {
|
||||
// Create a new app object for each connection, copy global data like db connections
|
||||
mut request_app := &T{}
|
||||
$if T is DbInterface {
|
||||
request_app.db = global_app.db
|
||||
} $else {
|
||||
// println('vweb no db')
|
||||
}
|
||||
$for field in T.fields {
|
||||
if 'vweb_global' in field.attrs || field.is_shared {
|
||||
request_app.$(field.name) = global_app.$(field.name)
|
||||
}
|
||||
}
|
||||
request_app.Context = global_app.Context // copy the context ref that contains static files map etc
|
||||
mut conn := l.accept() or {
|
||||
// failures should not panic
|
||||
eprintln('accept() failed with error: $err.msg')
|
||||
continue
|
||||
}
|
||||
go handle_conn<T>(mut conn, mut request_app, routes)
|
||||
}
|
||||
}
|
||||
|
||||
[manualfree]
|
||||
fn handle_conn<T>(mut conn net.TcpConn, mut app T, routes map[string]Route) {
|
||||
conn.set_read_timeout(30 * time.second)
|
||||
conn.set_write_timeout(30 * time.second)
|
||||
defer {
|
||||
conn.close() or {}
|
||||
unsafe {
|
||||
free(app)
|
||||
}
|
||||
}
|
||||
|
||||
mut reader := io.new_buffered_reader(reader: conn)
|
||||
defer {
|
||||
reader.free()
|
||||
}
|
||||
|
||||
page_gen_start := time.ticks()
|
||||
|
||||
// Request parse
|
||||
req := http.parse_request(mut reader) or {
|
||||
// Prevents errors from being thrown when BufferedReader is empty
|
||||
if '$err' != 'none' {
|
||||
eprintln('error parsing request: $err')
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// URL Parse
|
||||
url := urllib.parse(req.url) or {
|
||||
eprintln('error parsing path: $err')
|
||||
return
|
||||
}
|
||||
|
||||
// Query parse
|
||||
query := parse_query_from_url(url)
|
||||
url_words := url.path.split('/').filter(it != '')
|
||||
|
||||
// Form parse
|
||||
form, files := parse_form_from_request(req) or {
|
||||
// Bad request
|
||||
conn.write(vweb.http_400.bytes()) or {}
|
||||
return
|
||||
}
|
||||
|
||||
app.Context = Context{
|
||||
req: req
|
||||
page_gen_start: page_gen_start
|
||||
conn: conn
|
||||
query: query
|
||||
form: form
|
||||
files: files
|
||||
static_files: app.static_files
|
||||
static_mime_types: app.static_mime_types
|
||||
}
|
||||
|
||||
// Calling middleware...
|
||||
app.before_request()
|
||||
|
||||
// Static handling
|
||||
if serve_if_static<T>(mut app, url) {
|
||||
// successfully served a static file
|
||||
return
|
||||
}
|
||||
|
||||
// Route matching
|
||||
$for method in T.methods {
|
||||
$if method.return_type is Result {
|
||||
route := routes[method.name] or {
|
||||
eprintln('parsed attributes for the `$method.name` are not found, skipping...')
|
||||
Route{}
|
||||
}
|
||||
|
||||
// Skip if the HTTP request method does not match the attributes
|
||||
if req.method in route.methods {
|
||||
// Used for route matching
|
||||
route_words := route.path.split('/').filter(it != '')
|
||||
|
||||
// Route immediate matches first
|
||||
// For example URL `/register` matches route `/:user`, but `fn register()`
|
||||
// should be called first.
|
||||
if !route.path.contains('/:') && url_words == route_words {
|
||||
// We found a match
|
||||
if req.method == .post && method.args.len > 0 {
|
||||
// Populate method args with form values
|
||||
mut args := []string{cap: method.args.len}
|
||||
for param in method.args {
|
||||
args << form[param.name]
|
||||
}
|
||||
app.$method(args)
|
||||
} else {
|
||||
app.$method()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
if url_words.len == 0 && route_words == ['index'] && method.name == 'index' {
|
||||
app.$method()
|
||||
return
|
||||
}
|
||||
|
||||
if params := route_matches(url_words, route_words) {
|
||||
method_args := params.clone()
|
||||
if method_args.len != method.args.len {
|
||||
eprintln('warning: uneven parameters count ($method.args.len) in `$method.name`, compared to the vweb route `$method.attrs` ($method_args.len)')
|
||||
}
|
||||
app.$method(method_args)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Route not found
|
||||
conn.write(vweb.http_404.bytes()) or {}
|
||||
}
|
||||
|
||||
fn route_matches(url_words []string, route_words []string) ?[]string {
|
||||
// URL path should be at least as long as the route path
|
||||
// except for the catchall route (`/:path...`)
|
||||
if route_words.len == 1 && route_words[0].starts_with(':') && route_words[0].ends_with('...') {
|
||||
return ['/' + url_words.join('/')]
|
||||
}
|
||||
if url_words.len < route_words.len {
|
||||
return none
|
||||
}
|
||||
|
||||
mut params := []string{cap: url_words.len}
|
||||
if url_words.len == route_words.len {
|
||||
for i in 0 .. url_words.len {
|
||||
if route_words[i].starts_with(':') {
|
||||
// We found a path paramater
|
||||
params << url_words[i]
|
||||
} else if route_words[i] != url_words[i] {
|
||||
// This url does not match the route
|
||||
return none
|
||||
}
|
||||
}
|
||||
return params
|
||||
}
|
||||
|
||||
// The last route can end with ... indicating an array
|
||||
if route_words.len == 0 || !route_words[route_words.len - 1].ends_with('...') {
|
||||
return none
|
||||
}
|
||||
|
||||
for i in 0 .. route_words.len - 1 {
|
||||
if route_words[i].starts_with(':') {
|
||||
// We found a path paramater
|
||||
params << url_words[i]
|
||||
} else if route_words[i] != url_words[i] {
|
||||
// This url does not match the route
|
||||
return none
|
||||
}
|
||||
}
|
||||
params << url_words[route_words.len - 1..url_words.len].join('/')
|
||||
return params
|
||||
}
|
||||
|
||||
// check if request is for a static file and serves it
|
||||
// returns true if we served a static file, false otherwise
|
||||
[manualfree]
|
||||
fn serve_if_static<T>(mut app T, url urllib.URL) bool {
|
||||
// TODO: handle url parameters properly - for now, ignore them
|
||||
static_file := app.static_files[url.path]
|
||||
mime_type := app.static_mime_types[url.path]
|
||||
if static_file == '' || mime_type == '' {
|
||||
return false
|
||||
}
|
||||
data := os.read_file(static_file) or {
|
||||
send_string(mut app.conn, vweb.http_404.bytestr()) or {}
|
||||
return true
|
||||
}
|
||||
app.send_response_to_client(mime_type, data)
|
||||
unsafe { data.free() }
|
||||
return true
|
||||
}
|
||||
|
||||
fn (mut ctx Context) scan_static_directory(directory_path string, mount_path string) {
|
||||
files := os.ls(directory_path) or { panic(err) }
|
||||
if files.len > 0 {
|
||||
for file in files {
|
||||
full_path := os.join_path(directory_path, file)
|
||||
if os.is_dir(full_path) {
|
||||
ctx.scan_static_directory(full_path, mount_path + '/' + file)
|
||||
} else if file.contains('.') && !file.starts_with('.') && !file.ends_with('.') {
|
||||
ext := os.file_ext(file)
|
||||
// Rudimentary guard against adding files not in mime_types.
|
||||
// Use serve_static directly to add non-standard mime types.
|
||||
if ext in vweb.mime_types {
|
||||
ctx.serve_static(mount_path + '/' + file, full_path)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Handles a directory static
|
||||
// If `root` is set the mount path for the dir will be in '/'
|
||||
pub fn (mut ctx Context) handle_static(directory_path string, root bool) bool {
|
||||
if ctx.done || !os.exists(directory_path) {
|
||||
return false
|
||||
}
|
||||
dir_path := directory_path.trim_space().trim_right('/')
|
||||
mut mount_path := ''
|
||||
if dir_path != '.' && os.is_dir(dir_path) && !root {
|
||||
// Mount point hygene, "./assets" => "/assets".
|
||||
mount_path = '/' + dir_path.trim_left('.').trim('/')
|
||||
}
|
||||
ctx.scan_static_directory(dir_path, mount_path)
|
||||
return true
|
||||
}
|
||||
|
||||
// mount_static_folder_at - makes all static files in `directory_path` and inside it, available at http://server/mount_path
|
||||
// For example: suppose you have called .mount_static_folder_at('/var/share/myassets', '/assets'),
|
||||
// and you have a file /var/share/myassets/main.css .
|
||||
// => That file will be available at URL: http://server/assets/main.css .
|
||||
pub fn (mut ctx Context) mount_static_folder_at(directory_path string, mount_path string) bool {
|
||||
if ctx.done || mount_path.len < 1 || mount_path[0] != `/` || !os.exists(directory_path) {
|
||||
return false
|
||||
}
|
||||
dir_path := directory_path.trim_right('/')
|
||||
ctx.scan_static_directory(dir_path, mount_path[1..])
|
||||
return true
|
||||
}
|
||||
|
||||
// Serves a file static
|
||||
// `url` is the access path on the site, `file_path` is the real path to the file, `mime_type` is the file type
|
||||
pub fn (mut ctx Context) serve_static(url string, file_path string) {
|
||||
ctx.static_files[url] = file_path
|
||||
// ctx.static_mime_types[url] = mime_type
|
||||
ext := os.file_ext(file_path)
|
||||
ctx.static_mime_types[url] = vweb.mime_types[ext]
|
||||
}
|
||||
|
||||
// Returns the ip address from the current user
|
||||
pub fn (ctx &Context) ip() string {
|
||||
mut ip := ctx.req.header.get(.x_forwarded_for) or { '' }
|
||||
if ip == '' {
|
||||
ip = ctx.req.header.get_custom('X-Real-Ip') or { '' }
|
||||
}
|
||||
|
||||
if ip.contains(',') {
|
||||
ip = ip.all_before(',')
|
||||
}
|
||||
if ip == '' {
|
||||
ip = ctx.conn.peer_ip() or { '' }
|
||||
}
|
||||
return ip
|
||||
}
|
||||
|
||||
// Set s to the form error
|
||||
pub fn (mut ctx Context) error(s string) {
|
||||
println('vweb error: $s')
|
||||
ctx.form_error = s
|
||||
}
|
||||
|
||||
// Returns an empty result
|
||||
pub fn not_found() Result {
|
||||
return Result{}
|
||||
}
|
||||
|
||||
fn send_string(mut conn net.TcpConn, s string) ? {
|
||||
conn.write(s.bytes()) ?
|
||||
}
|
||||
|
||||
// Do not delete.
|
||||
// It used by `vlib/v/gen/c/str_intp.v:130` for string interpolation inside vweb templates
|
||||
// TODO: move it to template render
|
||||
fn filter(s string) string {
|
||||
return s.replace_each([
|
||||
'<',
|
||||
'<',
|
||||
'"',
|
||||
'"',
|
||||
'&',
|
||||
'&',
|
||||
])
|
||||
}
|
|
@ -0,0 +1,78 @@
|
|||
module main
|
||||
|
||||
import vweb
|
||||
import time
|
||||
import sqlite
|
||||
|
||||
struct App {
|
||||
vweb.Context
|
||||
pub mut:
|
||||
db sqlite.DB
|
||||
user_id string
|
||||
}
|
||||
|
||||
struct Article {
|
||||
id int
|
||||
title string
|
||||
text string
|
||||
}
|
||||
|
||||
fn test_a_vweb_application_compiles() {
|
||||
go fn () {
|
||||
time.sleep(2 * time.second)
|
||||
exit(0)
|
||||
}()
|
||||
vweb.run(&App{}, 18081)
|
||||
}
|
||||
|
||||
/*
|
||||
/TODO
|
||||
pub fn (mut app App) init_server_old() {
|
||||
app.db = sqlite.connect('blog.db') or { panic(err) }
|
||||
app.db.create_table('article', [
|
||||
'id integer primary key',
|
||||
"title text default ''",
|
||||
"text text default ''",
|
||||
])
|
||||
}
|
||||
*/
|
||||
|
||||
pub fn (mut app App) before_request() {
|
||||
app.user_id = app.get_cookie('id') or { '0' }
|
||||
}
|
||||
|
||||
['/new_article'; post]
|
||||
pub fn (mut app App) new_article() vweb.Result {
|
||||
title := app.form['title']
|
||||
text := app.form['text']
|
||||
if title == '' || text == '' {
|
||||
return app.text('Empty text/title')
|
||||
}
|
||||
article := Article{
|
||||
title: title
|
||||
text: text
|
||||
}
|
||||
println('posting article')
|
||||
println(article)
|
||||
sql app.db {
|
||||
insert article into Article
|
||||
}
|
||||
|
||||
return app.redirect('/')
|
||||
}
|
||||
|
||||
fn (mut app App) time() {
|
||||
app.text(time.now().format())
|
||||
}
|
||||
|
||||
fn (mut app App) time_json() {
|
||||
app.json({
|
||||
'time': time.now().format()
|
||||
})
|
||||
}
|
||||
|
||||
fn (mut app App) time_json_pretty() {
|
||||
app.json_pretty({
|
||||
'time': time.now().format()
|
||||
})
|
||||
}
|
Loading…
Reference in New Issue