mirror of
https://github.com/PeernetOfficial/WebGatewayUpload.git
synced 2026-07-16 19:47:51 +01:00
better debug errors
This commit is contained in:
406
main.go
406
main.go
@@ -1,42 +1,42 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"github.com/PeernetOfficial/core"
|
||||
"github.com/PeernetOfficial/core/btcec"
|
||||
"github.com/PeernetOfficial/core/webapi"
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/google/uuid"
|
||||
limiter "github.com/julianshen/gin-limiter"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"mime/multipart"
|
||||
"net/http"
|
||||
"time"
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"github.com/PeernetOfficial/core"
|
||||
"github.com/PeernetOfficial/core/btcec"
|
||||
"github.com/PeernetOfficial/core/webapi"
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/google/uuid"
|
||||
limiter "github.com/julianshen/gin-limiter"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"mime/multipart"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Variables for the flags to get the address
|
||||
var (
|
||||
// BackEndApiAddress Refers to the Peernet address ex: <address>:<port no>
|
||||
BackEndApiAddress *string
|
||||
// WebpageAddress Refers to the address for upload webgate server
|
||||
WebpageAddress *string
|
||||
// SSL To ensure SSL is required checks if SSL is required and subsequently
|
||||
// checks if the certificate is provided
|
||||
SSL *bool
|
||||
// Certificate SSL Certificate file
|
||||
Certificate *string
|
||||
// Key SSL Key file
|
||||
Key *string
|
||||
// BackendAddressWithHTTP ex: http://<address>:<port no>
|
||||
BackendAddressWithHTTP string
|
||||
// Production mode
|
||||
Production *bool
|
||||
// BackEndApiAddress Refers to the Peernet address ex: <address>:<port no>
|
||||
BackEndApiAddress *string
|
||||
// WebpageAddress Refers to the address for upload webgate server
|
||||
WebpageAddress *string
|
||||
// SSL To ensure SSL is required checks if SSL is required and subsequently
|
||||
// checks if the certificate is provided
|
||||
SSL *bool
|
||||
// Certificate SSL Certificate file
|
||||
Certificate *string
|
||||
// Key SSL Key file
|
||||
Key *string
|
||||
// BackendAddressWithHTTP ex: http://<address>:<port no>
|
||||
BackendAddressWithHTTP string
|
||||
// Production mode
|
||||
Production *bool
|
||||
)
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
@@ -45,33 +45,33 @@ var (
|
||||
|
||||
// init reading flags before any part of the code is executed
|
||||
func init() {
|
||||
BackEndApiAddress = flag.String("BackEndApiAddress", "localhost:8088", "current environment")
|
||||
WebpageAddress = flag.String("WebpageAddress", "localhost:8098", "current environment")
|
||||
SSL = flag.Bool("SSL", false, "Flag to check if the SSL certificate is enabled or not")
|
||||
Certificate = flag.String("Certificate", "server.crt", "SSL Certificate file")
|
||||
Key = flag.String("Key", "server.key", "SSL Key file")
|
||||
Production = flag.Bool("Production", false, "Flag to check if required to run on production mode")
|
||||
BackEndApiAddress = flag.String("BackEndApiAddress", "localhost:8088", "current environment")
|
||||
WebpageAddress = flag.String("WebpageAddress", "localhost:8098", "current environment")
|
||||
SSL = flag.Bool("SSL", false, "Flag to check if the SSL certificate is enabled or not")
|
||||
Certificate = flag.String("Certificate", "server.crt", "SSL Certificate file")
|
||||
Key = flag.String("Key", "server.key", "SSL Key file")
|
||||
Production = flag.Bool("Production", false, "Flag to check if required to run on production mode")
|
||||
}
|
||||
|
||||
// InitPeernet Initializes Peernet backend
|
||||
func InitPeernet() *core.Backend {
|
||||
backend, status, err := core.Init("Peernet Upload Application/1.0", "Config.yaml", nil, nil)
|
||||
if status != core.ExitSuccess {
|
||||
fmt.Printf("Error %d initializing backend: %s\n", status, err.Error())
|
||||
return nil
|
||||
}
|
||||
backend, status, err := core.Init("Peernet Upload Application/1.0", "Config.yaml", nil, nil)
|
||||
if status != core.ExitSuccess {
|
||||
fmt.Printf("Error %d initializing backend: %s\n", status, err.Error())
|
||||
return nil
|
||||
}
|
||||
|
||||
return backend
|
||||
return backend
|
||||
}
|
||||
|
||||
// RunPeernet Starts the WebAPI and peernet
|
||||
func RunPeernet(backend *core.Backend) {
|
||||
webapi.Start(backend, []string{*BackEndApiAddress}, false, "", "", 10*time.Second, 10*time.Second, uuid.Nil)
|
||||
backend.Connect()
|
||||
webapi.Start(backend, []string{*BackEndApiAddress}, false, "", "", 10*time.Second, 10*time.Second, uuid.Nil)
|
||||
backend.Connect()
|
||||
|
||||
for {
|
||||
for {
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
@@ -84,8 +84,8 @@ func RunPeernet(backend *core.Backend) {
|
||||
// ---------------------------------- Warehouse related structs ---------------------------
|
||||
|
||||
type WarehouseResult struct {
|
||||
Status int `json:"status"`
|
||||
Hash []byte `json:"hash"`
|
||||
Status int `json:"status"`
|
||||
Hash []byte `json:"hash"`
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------------------
|
||||
@@ -93,20 +93,20 @@ type WarehouseResult struct {
|
||||
|
||||
// BlockchainRequest blockchain backend API request struct
|
||||
type BlockchainRequest struct {
|
||||
Files []File `json:"files"`
|
||||
Files []File `json:"files"`
|
||||
}
|
||||
|
||||
type File struct {
|
||||
Hash []byte `json:"hash"`
|
||||
Type uint16 `json:"type"`
|
||||
Name string `json:"name"`
|
||||
Hash []byte `json:"hash"`
|
||||
Type uint16 `json:"type"`
|
||||
Name string `json:"name"`
|
||||
}
|
||||
|
||||
// BlockchainResponse blockchain backend API response struct
|
||||
type BlockchainResponse struct {
|
||||
Status int `json:"status"`
|
||||
Height int `json:"height"`
|
||||
Version int `json:"version"`
|
||||
Status int `json:"status"`
|
||||
Height int `json:"height"`
|
||||
Version int `json:"version"`
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------------------
|
||||
@@ -123,53 +123,53 @@ type BlockchainResponse struct {
|
||||
|
||||
// AddFileWarehouse API call for (Storing file in the warehouse)
|
||||
func AddFileWarehouse(file io.Reader) *WarehouseResult {
|
||||
url := BackendAddressWithHTTP + "/warehouse/create"
|
||||
url := BackendAddressWithHTTP + "/warehouse/create"
|
||||
|
||||
req, err := http.NewRequest("POST", url, file)
|
||||
//req.Header.Set("X-Custom-Header", "myvalue")
|
||||
//req.Header.Set("Content-Type", "application/json")
|
||||
req, err := http.NewRequest("POST", url, file)
|
||||
//req.Header.Set("X-Custom-Header", "myvalue")
|
||||
//req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
client := &http.Client{}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
client := &http.Client{}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
body, err := ioutil.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
var result WarehouseResult
|
||||
err = json.Unmarshal(body, &result)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
body, err := ioutil.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
var result WarehouseResult
|
||||
err = json.Unmarshal(body, &result)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
|
||||
return &result
|
||||
return &result
|
||||
}
|
||||
|
||||
// UploadFile Simple abstracted function to add files to peernet core
|
||||
func UploadFile(backend *core.Backend, file *multipart.File, header *multipart.FileHeader) (*btcec.PublicKey, *WarehouseResult, error) {
|
||||
buf := bytes.NewBuffer(nil)
|
||||
if _, err := io.Copy(buf, *file); err != nil {
|
||||
return nil, nil, errors.New("io.Copy not successful")
|
||||
}
|
||||
buf := bytes.NewBuffer(nil)
|
||||
if _, err := io.Copy(buf, *file); err != nil {
|
||||
return nil, nil, errors.New("io.Copy not successful")
|
||||
}
|
||||
|
||||
// adds file to warehouse
|
||||
warehouseResult := AddFileWarehouse(buf)
|
||||
// current using default port for Peernet api which is 8080
|
||||
// First add file to warehouse
|
||||
// adds file to warehouse
|
||||
warehouseResult := AddFileWarehouse(buf)
|
||||
// current using default port for Peernet api which is 8080
|
||||
// First add file to warehouse
|
||||
|
||||
// Adds the file to a blockchain
|
||||
Blockchainfo := AddFileToBlockchain(warehouseResult.Hash, header.Filename)
|
||||
if Blockchainfo == nil {
|
||||
return nil, nil, errors.New("add file to blockchain not successful")
|
||||
}
|
||||
// Adds the file to a blockchain
|
||||
Blockchainfo := AddFileToBlockchain(warehouseResult.Hash, header.Filename)
|
||||
if Blockchainfo == nil {
|
||||
return nil, nil, errors.New("add file to blockchain not successful")
|
||||
}
|
||||
|
||||
_, publicKey := backend.ExportPrivateKey()
|
||||
_, publicKey := backend.ExportPrivateKey()
|
||||
|
||||
return publicKey, warehouseResult, nil
|
||||
return publicKey, warehouseResult, nil
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------------------
|
||||
@@ -177,45 +177,45 @@ func UploadFile(backend *core.Backend, file *multipart.File, header *multipart.F
|
||||
|
||||
// AddFileToBlockchain The follwoing function adds the filename and hash to the blockchain
|
||||
func AddFileToBlockchain(hash []byte, filename string) *BlockchainResponse {
|
||||
url := BackendAddressWithHTTP + "/blockchain/file/add"
|
||||
url := BackendAddressWithHTTP + "/blockchain/file/add"
|
||||
|
||||
// Get file type
|
||||
detectType, _, err := webapi.FileDetectType(filename)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
// Get file type
|
||||
detectType, _, err := webapi.FileDetectType(filename)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
// Create file object for post
|
||||
var blockchainRequest BlockchainRequest
|
||||
var files File
|
||||
files.Name = filename
|
||||
files.Hash = hash
|
||||
files.Type = detectType
|
||||
blockchainRequest.Files = append(blockchainRequest.Files, files)
|
||||
// Create file object for post
|
||||
var blockchainRequest BlockchainRequest
|
||||
var files File
|
||||
files.Name = filename
|
||||
files.Hash = hash
|
||||
files.Type = detectType
|
||||
blockchainRequest.Files = append(blockchainRequest.Files, files)
|
||||
|
||||
Byte, err := json.Marshal(blockchainRequest)
|
||||
Byte, err := json.Marshal(blockchainRequest)
|
||||
|
||||
// convert bytes
|
||||
req, err := http.NewRequest("POST", url, bytes.NewBuffer(Byte))
|
||||
//req.Header.Set("X-Custom-Header", "myvalue")
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
// convert bytes
|
||||
req, err := http.NewRequest("POST", url, bytes.NewBuffer(Byte))
|
||||
//req.Header.Set("X-Custom-Header", "myvalue")
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
client := &http.Client{}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
client := &http.Client{}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
body, _ := ioutil.ReadAll(resp.Body)
|
||||
body, _ := ioutil.ReadAll(resp.Body)
|
||||
|
||||
var result BlockchainResponse
|
||||
err = json.Unmarshal(body, &result)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
var result BlockchainResponse
|
||||
err = json.Unmarshal(body, &result)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &result
|
||||
return &result
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------------------
|
||||
@@ -226,99 +226,99 @@ func AddFileToBlockchain(hash []byte, filename string) *BlockchainResponse {
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
func main() {
|
||||
// Parsing flags
|
||||
flag.Parse()
|
||||
// Parsing flags
|
||||
flag.Parse()
|
||||
|
||||
// Start peernet
|
||||
backend := InitPeernet()
|
||||
go RunPeernet(backend)
|
||||
// Start peernet
|
||||
backend := InitPeernet()
|
||||
go RunPeernet(backend)
|
||||
|
||||
var r *gin.Engine
|
||||
if *Production {
|
||||
gin.SetMode(gin.ReleaseMode)
|
||||
r = gin.New()
|
||||
} else {
|
||||
r = gin.Default()
|
||||
}
|
||||
|
||||
r.LoadHTMLGlob("templates/*.html")
|
||||
r.Static("/templates", "./templates")
|
||||
var r *gin.Engine
|
||||
if *Production {
|
||||
gin.SetMode(gin.ReleaseMode)
|
||||
r = gin.New()
|
||||
} else {
|
||||
r = gin.Default()
|
||||
}
|
||||
|
||||
// --------------------------------- Middleware rate limiter -----------------------------------
|
||||
lm := limiter.NewRateLimiter(time.Minute, 10, func(ctx *gin.Context) (string, error) {
|
||||
return "", nil
|
||||
})
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
r.LoadHTMLGlob("templates/*.html")
|
||||
r.Static("/templates", "./templates")
|
||||
|
||||
// ---------------------------------------- Routes ---------------------------------------------
|
||||
// GET /upload to open upload page from webgateway
|
||||
r.GET("/upload", lm.Middleware(), func(c *gin.Context) {
|
||||
c.HTML(http.StatusOK, "upload.html", nil)
|
||||
})
|
||||
// --------------------------------- Middleware rate limiter -----------------------------------
|
||||
lm := limiter.NewRateLimiter(time.Minute, 10, func(ctx *gin.Context) (string, error) {
|
||||
return "", nil
|
||||
})
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
|
||||
// POST /uploadFile Uploads file to peernet from Webgateway
|
||||
r.POST("/upload", lm.Middleware(), func(c *gin.Context) {
|
||||
file, header, err := c.Request.FormFile("file")
|
||||
defer file.Close()
|
||||
// ---------------------------------------- Routes ---------------------------------------------
|
||||
// GET /upload to open upload page from webgateway
|
||||
r.GET("/upload", lm.Middleware(), func(c *gin.Context) {
|
||||
c.HTML(http.StatusOK, "upload.html", nil)
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
c.HTML(http.StatusBadRequest, "upload.html", gin.H{
|
||||
"error": "File not added during upload",
|
||||
})
|
||||
return
|
||||
}
|
||||
// POST /uploadFile Uploads file to peernet from Webgateway
|
||||
r.POST("/upload", lm.Middleware(), func(c *gin.Context) {
|
||||
file, header, err := c.Request.FormFile("file")
|
||||
defer file.Close()
|
||||
|
||||
publicKey, warehouseResult, err := UploadFile(backend, &file, header)
|
||||
if err != nil {
|
||||
c.HTML(http.StatusBadRequest, "upload.html", gin.H{
|
||||
"error": "File not added during upload",
|
||||
})
|
||||
return
|
||||
//fmt.Println(err)
|
||||
}
|
||||
if err != nil {
|
||||
c.HTML(http.StatusBadRequest, "upload.html", gin.H{
|
||||
"error": err,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
c.HTML(http.StatusOK, "upload.html", gin.H{
|
||||
"hash": hex.EncodeToString(warehouseResult.Hash),
|
||||
"filename": header.Filename,
|
||||
"size": header.Size,
|
||||
"link": "https://peer.ae/" + hex.EncodeToString(publicKey.SerializeCompressed()) + "/" + hex.EncodeToString(warehouseResult.Hash),
|
||||
"address": *WebpageAddress,
|
||||
})
|
||||
publicKey, warehouseResult, err := UploadFile(backend, &file, header)
|
||||
if err != nil {
|
||||
c.HTML(http.StatusBadRequest, "upload.html", gin.H{
|
||||
"error": err,
|
||||
})
|
||||
return
|
||||
//fmt.Println(err)
|
||||
}
|
||||
|
||||
})
|
||||
c.HTML(http.StatusOK, "upload.html", gin.H{
|
||||
"hash": hex.EncodeToString(warehouseResult.Hash),
|
||||
"filename": header.Filename,
|
||||
"size": header.Size,
|
||||
"link": "https://peer.ae/" + hex.EncodeToString(publicKey.SerializeCompressed()) + "/" + hex.EncodeToString(warehouseResult.Hash),
|
||||
"address": *WebpageAddress,
|
||||
})
|
||||
|
||||
// Implement CURL script to ensure linux users can upload directly
|
||||
// the Cli like https://bashupload.com
|
||||
// Ex: curl http://localhost:8080/uploadCurl -F add=@<file name>
|
||||
r.POST("/uploadCurl", lm.Middleware(), func(c *gin.Context) {
|
||||
file, header, err := c.Request.FormFile("add")
|
||||
defer file.Close()
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
// Implement CURL script to ensure linux users can upload directly
|
||||
// the Cli like https://bashupload.com
|
||||
// Ex: curl http://localhost:8080/uploadCurl -F add=@<file name>
|
||||
r.POST("/uploadCurl", lm.Middleware(), func(c *gin.Context) {
|
||||
file, header, err := c.Request.FormFile("add")
|
||||
defer file.Close()
|
||||
|
||||
publicKey, warehouseResult, err := UploadFile(backend, &file, header)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
|
||||
link := "https://peer.ae/" + hex.EncodeToString(publicKey.SerializeCompressed()) + "/" + hex.EncodeToString(warehouseResult.Hash)
|
||||
c.Data(http.StatusOK, "plain/text", []byte(link))
|
||||
})
|
||||
publicKey, warehouseResult, err := UploadFile(backend, &file, header)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
link := "https://peer.ae/" + hex.EncodeToString(publicKey.SerializeCompressed()) + "/" + hex.EncodeToString(warehouseResult.Hash)
|
||||
c.Data(http.StatusOK, "plain/text", []byte(link))
|
||||
})
|
||||
|
||||
// ---------------------------------- Start Gin server -----------------------------------------
|
||||
// check if SSL is used or not
|
||||
if *SSL {
|
||||
BackendAddressWithHTTP = "https://" + *BackEndApiAddress
|
||||
r.RunTLS(*WebpageAddress, *Certificate, *Key)
|
||||
*WebpageAddress = "https://" + *WebpageAddress
|
||||
} else {
|
||||
BackendAddressWithHTTP = "http://" + *BackEndApiAddress
|
||||
r.Run(*WebpageAddress)
|
||||
*WebpageAddress = "http://" + *WebpageAddress
|
||||
}
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
|
||||
// ---------------------------------- Start Gin server -----------------------------------------
|
||||
// check if SSL is used or not
|
||||
if *SSL {
|
||||
BackendAddressWithHTTP = "https://" + *BackEndApiAddress
|
||||
r.RunTLS(*WebpageAddress, *Certificate, *Key)
|
||||
*WebpageAddress = "https://" + *WebpageAddress
|
||||
} else {
|
||||
BackendAddressWithHTTP = "http://" + *BackEndApiAddress
|
||||
r.Run(*WebpageAddress)
|
||||
*WebpageAddress = "http://" + *WebpageAddress
|
||||
}
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user