Skip to content
Projects
Groups
Snippets
Help
Loading...
Sign in
Toggle navigation
B
beego
Project
Project
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
0
Issues
0
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Commits
Issue Boards
Open sidebar
go
beego
Commits
d0d28566
Commit
d0d28566
authored
Nov 10, 2018
by
Viktor Vassilyev
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
chore(GoMod): add dependency go-bindata-assetfs in vendor dir
parent
872b787e
Expand all
Hide whitespace changes
Inline
Side-by-side
Showing
9 changed files
with
424 additions
and
0 deletions
+424
-0
go.sum
go.sum
+1
-0
lz4.c
vendor/github.com/cloudflare/golz4/src/lz4.c
+0
-0
lz4.h
vendor/github.com/cloudflare/golz4/src/lz4.h
+0
-0
lz4hc.c
vendor/github.com/cloudflare/golz4/src/lz4hc.c
+0
-0
lz4hc.h
vendor/github.com/cloudflare/golz4/src/lz4hc.h
+174
-0
LICENSE
vendor/github.com/elazarl/go-bindata-assetfs/LICENSE
+23
-0
README.md
vendor/github.com/elazarl/go-bindata-assetfs/README.md
+46
-0
assetfs.go
vendor/github.com/elazarl/go-bindata-assetfs/assetfs.go
+167
-0
doc.go
vendor/github.com/elazarl/go-bindata-assetfs/doc.go
+13
-0
No files found.
go.sum
View file @
d0d28566
...
...
@@ -26,6 +26,7 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712 h1:aaQcKT9WumO6JEJcRyTqFVq4XUZiUcKR2/GI31TOcz8=
github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
github.com/elazarl/go-bindata-assetfs v0.0.0-20180223110309-38087fe4dafb h1:T6FhFH6fLQPEu7n7PauDhb4mhpxhlfaL7a7MZEpIgDc=
github.com/elazarl/go-bindata-assetfs v0.0.0-20180223110309-38087fe4dafb/go.mod h1:v+YaWX3bdea5J/mo8dSETolEo7R71Vk1u8bnjau5yw4=
github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
...
...
vendor/github.com/cloudflare/golz4/src/lz4.c
0 → 100644
View file @
d0d28566
This diff is collapsed.
Click to expand it.
vendor/github.com/cloudflare/golz4/src/lz4.h
0 → 100644
View file @
d0d28566
This diff is collapsed.
Click to expand it.
vendor/github.com/cloudflare/golz4/src/lz4hc.c
0 → 100644
View file @
d0d28566
This diff is collapsed.
Click to expand it.
vendor/github.com/cloudflare/golz4/src/lz4hc.h
0 → 100644
View file @
d0d28566
/*
LZ4 HC - High Compression Mode of LZ4
Header File
Copyright (C) 2011-2014, Yann Collet.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
- LZ4 source repository : http://code.google.com/p/lz4/
*/
#pragma once
#if defined (__cplusplus)
extern
"C"
{
#endif
int
LZ4_compressHC
(
const
char
*
source
,
char
*
dest
,
int
inputSize
);
/*
LZ4_compressHC :
return : the number of bytes in compressed buffer dest
or 0 if compression fails.
note : destination buffer must be already allocated.
To avoid any problem, size it to handle worst cases situations (input data not compressible)
Worst case size evaluation is provided by function LZ4_compressBound() (see "lz4.h")
*/
int
LZ4_compressHC_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
/*
LZ4_compress_limitedOutput() :
Compress 'inputSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.
If it cannot achieve it, compression will stop, and result of the function will be zero.
This function never writes outside of provided output buffer.
inputSize : Max supported value is 1 GB
maxOutputSize : is maximum allowed size into the destination buffer (which must be already allocated)
return : the number of output bytes written in buffer 'dest'
or 0 if compression fails.
*/
int
LZ4_compressHC2
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
);
int
LZ4_compressHC2_limitedOutput
(
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
);
/*
Same functions as above, but with programmable 'compressionLevel'.
Recommended values are between 4 and 9, although any value between 0 and 16 will work.
'compressionLevel'==0 means use default 'compressionLevel' value.
Values above 16 behave the same as 16.
Equivalent variants exist for all other compression functions below.
*/
/* Note :
Decompression functions are provided within LZ4 source code (see "lz4.h") (BSD license)
*/
/**************************************
Using an external allocation
**************************************/
int
LZ4_sizeofStateHC
(
void
);
int
LZ4_compressHC_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
);
int
LZ4_compressHC_limitedOutput_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
int
LZ4_compressHC2_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
);
int
LZ4_compressHC2_limitedOutput_withStateHC
(
void
*
state
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
);
/*
These functions are provided should you prefer to allocate memory for compression tables with your own allocation methods.
To know how much memory must be allocated for the compression tables, use :
int LZ4_sizeofStateHC();
Note that tables must be aligned for pointer (32 or 64 bits), otherwise compression will fail (return code 0).
The allocated memory can be provided to the compression functions using 'void* state' parameter.
LZ4_compress_withStateHC() and LZ4_compress_limitedOutput_withStateHC() are equivalent to previously described functions.
They just use the externally allocated memory for state instead of allocating their own (on stack, or on heap).
*/
/**************************************
Experimental Streaming Functions
**************************************/
#define LZ4_STREAMHCSIZE_U64 32774
#define LZ4_STREAMHCSIZE (LZ4_STREAMHCSIZE_U64 * sizeof(unsigned long long))
typedef
struct
{
unsigned
long
long
table
[
LZ4_STREAMHCSIZE_U64
];
}
LZ4_streamHC_t
;
/*
LZ4_streamHC_t
This structure allows static allocation of LZ4 HC streaming state.
State must then be initialized using LZ4_resetStreamHC() before first use.
Static allocation should only be used with statically linked library.
If you want to use LZ4 as a DLL, please use construction functions below, which are more future-proof.
*/
LZ4_streamHC_t
*
LZ4_createStreamHC
(
void
);
int
LZ4_freeStreamHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
);
/*
These functions create and release memory for LZ4 HC streaming state.
Newly created states are already initialized.
Existing state space can be re-used anytime using LZ4_resetStreamHC().
If you use LZ4 as a DLL, please use these functions instead of direct struct allocation,
to avoid size mismatch between different versions.
*/
void
LZ4_resetStreamHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
int
compressionLevel
);
int
LZ4_loadDictHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
dictionary
,
int
dictSize
);
int
LZ4_compressHC_continue
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
);
int
LZ4_compressHC_limitedOutput_continue
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
);
int
LZ4_saveDictHC
(
LZ4_streamHC_t
*
LZ4_streamHCPtr
,
char
*
safeBuffer
,
int
maxDictSize
);
/*
These functions compress data in successive blocks of any size, using previous blocks as dictionary.
One key assumption is that each previous block will remain read-accessible while compressing next block.
Before starting compression, state must be properly initialized, using LZ4_resetStreamHC().
A first "fictional block" can then be designated as initial dictionary, using LZ4_loadDictHC() (Optional).
Then, use LZ4_compressHC_continue() or LZ4_compressHC_limitedOutput_continue() to compress each successive block.
They work like usual LZ4_compressHC() or LZ4_compressHC_limitedOutput(), but use previous memory blocks to improve compression.
Previous memory blocks (including initial dictionary when present) must remain accessible and unmodified during compression.
If, for any reason, previous data block can't be preserved in memory during next compression block,
you must save it to a safer memory space,
using LZ4_saveDictHC().
*/
/**************************************
* Deprecated Streaming Functions
* ************************************/
/* Note : these streaming functions follows the older model, and should no longer be used */
void
*
LZ4_createHC
(
const
char
*
inputBuffer
);
char
*
LZ4_slideInputBufferHC
(
void
*
LZ4HC_Data
);
int
LZ4_freeHC
(
void
*
LZ4HC_Data
);
int
LZ4_compressHC2_continue
(
void
*
LZ4HC_Data
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
compressionLevel
);
int
LZ4_compressHC2_limitedOutput_continue
(
void
*
LZ4HC_Data
,
const
char
*
source
,
char
*
dest
,
int
inputSize
,
int
maxOutputSize
,
int
compressionLevel
);
int
LZ4_sizeofStreamStateHC
(
void
);
int
LZ4_resetStreamStateHC
(
void
*
state
,
const
char
*
inputBuffer
);
#if defined (__cplusplus)
}
#endif
vendor/github.com/elazarl/go-bindata-assetfs/LICENSE
0 → 100644
View file @
d0d28566
Copyright (c) 2014, Elazar Leibovich
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
vendor/github.com/elazarl/go-bindata-assetfs/README.md
0 → 100644
View file @
d0d28566
# go-bindata-assetfs
Serve embedded files from
[
jteeuwen/go-bindata
](
https://github.com/jteeuwen/go-bindata
)
with
`net/http`
.
[
GoDoc
](
http://godoc.org/github.com/elazarl/go-bindata-assetfs
)
### Installation
Install with
$ go get github.com/jteeuwen/go-bindata/...
$ go get github.com/elazarl/go-bindata-assetfs/...
### Creating embedded data
Usage is identical to
[
jteeuwen/go-bindata
](
https://github.com/jteeuwen/go-bindata
)
usage,
instead of running
`go-bindata`
run
`go-bindata-assetfs`
.
The tool will create a
`bindata_assetfs.go`
file, which contains the embedded data.
A typical use case is
$ go-bindata-assetfs data/...
### Using assetFS in your code
The generated file provides an
`assetFS()`
function that returns a
`http.Filesystem`
wrapping the embedded files. What you usually want to do is:
http.Handle("/", http.FileServer(assetFS()))
This would run an HTTP server serving the embedded files.
## Without running binary tool
You can always just run the
`go-bindata`
tool, and then
use
import "github.com/elazarl/go-bindata-assetfs"
...
http.Handle("/",
http.FileServer(
&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, AssetInfo: AssetInfo, Prefix: "data"}))
to serve files embedded from the
`data`
directory.
vendor/github.com/elazarl/go-bindata-assetfs/assetfs.go
0 → 100644
View file @
d0d28566
package
assetfs
import
(
"bytes"
"errors"
"io"
"io/ioutil"
"net/http"
"os"
"path"
"path/filepath"
"strings"
"time"
)
var
(
defaultFileTimestamp
=
time
.
Now
()
)
// FakeFile implements os.FileInfo interface for a given path and size
type
FakeFile
struct
{
// Path is the path of this file
Path
string
// Dir marks of the path is a directory
Dir
bool
// Len is the length of the fake file, zero if it is a directory
Len
int64
// Timestamp is the ModTime of this file
Timestamp
time
.
Time
}
func
(
f
*
FakeFile
)
Name
()
string
{
_
,
name
:=
filepath
.
Split
(
f
.
Path
)
return
name
}
func
(
f
*
FakeFile
)
Mode
()
os
.
FileMode
{
mode
:=
os
.
FileMode
(
0644
)
if
f
.
Dir
{
return
mode
|
os
.
ModeDir
}
return
mode
}
func
(
f
*
FakeFile
)
ModTime
()
time
.
Time
{
return
f
.
Timestamp
}
func
(
f
*
FakeFile
)
Size
()
int64
{
return
f
.
Len
}
func
(
f
*
FakeFile
)
IsDir
()
bool
{
return
f
.
Mode
()
.
IsDir
()
}
func
(
f
*
FakeFile
)
Sys
()
interface
{}
{
return
nil
}
// AssetFile implements http.File interface for a no-directory file with content
type
AssetFile
struct
{
*
bytes
.
Reader
io
.
Closer
FakeFile
}
func
NewAssetFile
(
name
string
,
content
[]
byte
,
timestamp
time
.
Time
)
*
AssetFile
{
if
timestamp
.
IsZero
()
{
timestamp
=
defaultFileTimestamp
}
return
&
AssetFile
{
bytes
.
NewReader
(
content
),
ioutil
.
NopCloser
(
nil
),
FakeFile
{
name
,
false
,
int64
(
len
(
content
)),
timestamp
}}
}
func
(
f
*
AssetFile
)
Readdir
(
count
int
)
([]
os
.
FileInfo
,
error
)
{
return
nil
,
errors
.
New
(
"not a directory"
)
}
func
(
f
*
AssetFile
)
Size
()
int64
{
return
f
.
FakeFile
.
Size
()
}
func
(
f
*
AssetFile
)
Stat
()
(
os
.
FileInfo
,
error
)
{
return
f
,
nil
}
// AssetDirectory implements http.File interface for a directory
type
AssetDirectory
struct
{
AssetFile
ChildrenRead
int
Children
[]
os
.
FileInfo
}
func
NewAssetDirectory
(
name
string
,
children
[]
string
,
fs
*
AssetFS
)
*
AssetDirectory
{
fileinfos
:=
make
([]
os
.
FileInfo
,
0
,
len
(
children
))
for
_
,
child
:=
range
children
{
_
,
err
:=
fs
.
AssetDir
(
filepath
.
Join
(
name
,
child
))
fileinfos
=
append
(
fileinfos
,
&
FakeFile
{
child
,
err
==
nil
,
0
,
time
.
Time
{}})
}
return
&
AssetDirectory
{
AssetFile
{
bytes
.
NewReader
(
nil
),
ioutil
.
NopCloser
(
nil
),
FakeFile
{
name
,
true
,
0
,
time
.
Time
{}},
},
0
,
fileinfos
}
}
func
(
f
*
AssetDirectory
)
Readdir
(
count
int
)
([]
os
.
FileInfo
,
error
)
{
if
count
<=
0
{
return
f
.
Children
,
nil
}
if
f
.
ChildrenRead
+
count
>
len
(
f
.
Children
)
{
count
=
len
(
f
.
Children
)
-
f
.
ChildrenRead
}
rv
:=
f
.
Children
[
f
.
ChildrenRead
:
f
.
ChildrenRead
+
count
]
f
.
ChildrenRead
+=
count
return
rv
,
nil
}
func
(
f
*
AssetDirectory
)
Stat
()
(
os
.
FileInfo
,
error
)
{
return
f
,
nil
}
// AssetFS implements http.FileSystem, allowing
// embedded files to be served from net/http package.
type
AssetFS
struct
{
// Asset should return content of file in path if exists
Asset
func
(
path
string
)
([]
byte
,
error
)
// AssetDir should return list of files in the path
AssetDir
func
(
path
string
)
([]
string
,
error
)
// AssetInfo should return the info of file in path if exists
AssetInfo
func
(
path
string
)
(
os
.
FileInfo
,
error
)
// Prefix would be prepended to http requests
Prefix
string
}
func
(
fs
*
AssetFS
)
Open
(
name
string
)
(
http
.
File
,
error
)
{
name
=
path
.
Join
(
fs
.
Prefix
,
name
)
if
len
(
name
)
>
0
&&
name
[
0
]
==
'/'
{
name
=
name
[
1
:
]
}
if
b
,
err
:=
fs
.
Asset
(
name
);
err
==
nil
{
timestamp
:=
defaultFileTimestamp
if
fs
.
AssetInfo
!=
nil
{
if
info
,
err
:=
fs
.
AssetInfo
(
name
);
err
==
nil
{
timestamp
=
info
.
ModTime
()
}
}
return
NewAssetFile
(
name
,
b
,
timestamp
),
nil
}
if
children
,
err
:=
fs
.
AssetDir
(
name
);
err
==
nil
{
return
NewAssetDirectory
(
name
,
children
,
fs
),
nil
}
else
{
// If the error is not found, return an error that will
// result in a 404 error. Otherwise the server returns
// a 500 error for files not found.
if
strings
.
Contains
(
err
.
Error
(),
"not found"
)
{
return
nil
,
os
.
ErrNotExist
}
return
nil
,
err
}
}
vendor/github.com/elazarl/go-bindata-assetfs/doc.go
0 → 100644
View file @
d0d28566
// assetfs allows packages to serve static content embedded
// with the go-bindata tool with the standard net/http package.
//
// See https://github.com/jteeuwen/go-bindata for more information
// about embedding binary data with go-bindata.
//
// Usage example, after running
// $ go-bindata data/...
// use:
// http.Handle("/",
// http.FileServer(
// &assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: "data"}))
package
assetfs
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment