GOOS=js GOARCH=wasm go build -o main.wasm goexec 'http.ListenAndServe(":8080", http.FileServer(http.Dir(".")))'
Last active
June 16, 2020 22:42
-
-
Save mobyvb/37e58aafc918e5de6abd4d5445c675a7 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
module storj.test/buplink | |
go 1.15 | |
require ( | |
github.com/shurcooL/go v0.0.0-20200502201357-93f07166e636 // indirect | |
github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041 // indirect | |
storj.io/uplink v1.1.1 | |
) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= | |
github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= | |
github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= | |
github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= | |
github.com/btcsuite/btcutil v1.0.1 h1:GKOz8BnRjYrb/JTKgaOk+zh26NWNdSNvdvv0xoAZMSA= | |
github.com/btcsuite/btcutil v1.0.1/go.mod h1:j9HUFwoQRsZL3V4n+qG+CUnEGHOarIxfC3Le2Yhbcts= | |
github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg= | |
github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY= | |
github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= | |
github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= | |
github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= | |
github.com/calebcase/tmpfile v1.0.1 h1:vD8FSrbsbexhep39/6mvtbIHS3GzIRqiprDNCF6QqSk= | |
github.com/calebcase/tmpfile v1.0.1/go.mod h1:iErLeG/iqJr8LaQ/gYRv4GXdqssi3jg4iSzvrA06/lw= | |
github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= | |
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= | |
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/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= | |
github.com/gogo/protobuf v1.2.1 h1:/s5zKNz0uPFCZ5hddgPdo2TK2TVrUNMn0OOX8/aZMTE= | |
github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= | |
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= | |
github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= | |
github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= | |
github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= | |
github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= | |
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= | |
github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= | |
github.com/minio/sha256-simd v0.1.1 h1:5QHSlgo3nt5yKOJrC7W8w7X+NFl8cMPZm96iu8kKUJU= | |
github.com/minio/sha256-simd v0.1.1/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM= | |
github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= | |
github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= | |
github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= | |
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= | |
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= | |
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= | |
github.com/shurcooL/go v0.0.0-20200502201357-93f07166e636 h1:aSISeOcal5irEhJd1M+IrApc0PdcN7e7Aj4yuEnOrfQ= | |
github.com/shurcooL/go v0.0.0-20200502201357-93f07166e636/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk= | |
github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041 h1:llrF3Fs4018ePo4+G/HV/uQUqEI1HMDjCeOf2V6puPc= | |
github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ= | |
github.com/spacemonkeygo/monkit/v3 v3.0.4/go.mod h1:JcK1pCbReQsOsMKF/POFSZCq7drXFybgGmbc27tuwes= | |
github.com/spacemonkeygo/monkit/v3 v3.0.5/go.mod h1:JcK1pCbReQsOsMKF/POFSZCq7drXFybgGmbc27tuwes= | |
github.com/spacemonkeygo/monkit/v3 v3.0.7-0.20200515175308-072401d8c752 h1:WcQDknqg0qajLNYKv3mXgbkWlYs5rPgZehGJFWePHVI= | |
github.com/spacemonkeygo/monkit/v3 v3.0.7-0.20200515175308-072401d8c752/go.mod h1:kj1ViJhlyADa7DiA4xVnTuPA46lFKbM7mxQTrXCuJP4= | |
github.com/spacemonkeygo/monotime v0.0.0-20180824235756-e3f48a95f98a/go.mod h1:ul4bvvnCOPZgq8w0nTkSmWVg/hauVpFS97Am1YM1XXo= | |
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= | |
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= | |
github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= | |
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= | |
github.com/vivint/infectious v0.0.0-20200605153912-25a574ae18a3 h1:zMsHhfK9+Wdl1F7sIKLyx3wrOFofpb3rWFbA4HgcK5k= | |
github.com/vivint/infectious v0.0.0-20200605153912-25a574ae18a3/go.mod h1:R0Gbuw7ElaGSLOZUSwBm/GgVwMd30jWxBDdAyMOeTuc= | |
github.com/zeebo/admission/v3 v3.0.1/go.mod h1:BP3isIv9qa2A7ugEratNq1dnl2oZRXaQUGdU7WXKtbw= | |
github.com/zeebo/assert v1.1.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= | |
github.com/zeebo/errs v1.2.2 h1:5NFypMTuSdoySVTqlNs1dEoU21QVamMQJxW/Fii5O7g= | |
github.com/zeebo/errs v1.2.2/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4= | |
github.com/zeebo/float16 v0.1.0/go.mod h1:fssGvvXu+XS8MH57cKmyrLB/cqioYeYX/2mXCN3a5wo= | |
github.com/zeebo/incenc v0.0.0-20180505221441-0d92902eec54/go.mod h1:EI8LcOBDlSL3POyqwC1eJhOYlMBMidES+613EtmmT5w= | |
go.uber.org/atomic v1.4.0 h1:cxzIVoETapQEqDhQu3QfnvXAV4AlzcvUCxkVUFw3+EU= | |
go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= | |
go.uber.org/multierr v1.1.0 h1:HoEmRHQPVSqub6w2z2d2EOVs2fjyFRGyofhKuyDq0QI= | |
go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= | |
go.uber.org/zap v1.10.0 h1:ORx85nbTijNz8ljznvCMR1ZBIPKFn3jQrag10X2AsuM= | |
go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= | |
golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= | |
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= | |
golang.org/x/crypto v0.0.0-20200115085410-6d4e4cb37c7d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= | |
golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975 h1:/Tl7pH94bvbAAHBdZJT947M/+gp0+CqQXDtMRC0fseo= | |
golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= | |
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= | |
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= | |
golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= | |
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= | |
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY= | |
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= | |
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= | |
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= | |
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= | |
golang.org/x/sys v0.0.0-20191210023423-ac6580df4449/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= | |
golang.org/x/sys v0.0.0-20200107144601-ef85f5a75ddf/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= | |
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884= | |
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= | |
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= | |
golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= | |
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= | |
gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= | |
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= | |
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= | |
gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= | |
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= | |
storj.io/common v0.0.0-20200611114417-9a3d012fdb62 h1:y8vGNQ0HjtD79G8MfCwbs6hct40tSBoDaOnsxWOZpU4= | |
storj.io/common v0.0.0-20200611114417-9a3d012fdb62/go.mod h1:6S6Ub92/BB+ofU7hbyPcm96b4Q1ayyN0HLog+3u+wGc= | |
storj.io/drpc v0.0.12 h1:4ei1M4cnWlYxcQheX0Dg4+c12zCD+oJqfweVQVWarsA= | |
storj.io/drpc v0.0.12/go.mod h1:82nfl+6YwRwF6UG31cEWWUqv/FaKvP5SGqUvoqTxCMA= | |
storj.io/uplink v1.1.1 h1:oa5uoDtZDT58e3vy9yp24HKU1EaLs4TRM75DS+ICtqs= | |
storj.io/uplink v1.1.1/go.mod h1:UkdYN/dfSgv+d8fBUoZTrX2oLdj9gzX6Q7tp3CojgKA= |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<html> | |
<head> | |
<meta charset="utf-8"/> | |
<script src="sockets.js"></script> | |
<script src="wasm_exec.js"></script> | |
<script> | |
const go = new Go(); | |
WebAssembly.instantiateStreaming(fetch("main.wasm"), go.importObject).then((result) => { | |
go.run(result.instance); | |
}); | |
</script> | |
</head> | |
<body></body> | |
</html> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
package main | |
import ( | |
"bytes" | |
"context" | |
"fmt" | |
"io" | |
"io/ioutil" | |
"net" | |
"syscall/js" | |
"time" | |
"storj.io/uplink" | |
) | |
func main() { | |
var satellite string | |
var passphrase string | |
var apikey string | |
apikey = "13Yqcux9BQu4C1DyHjUbXispLV3qcTRws2NrGjBzi8MWZ4zLVBkZES3FPRD88y7ercGKKCDi7ud4aMEd2szmjL8HDYXXxEmXJs97CvQ" | |
satellite = "12Wz6wJihX8yrnYht21kokZNiorNcLY5i5ai61sTLBR7qEhNqbi@127.0.0.1:10000" | |
passphrase = "testpass" | |
err := UploadAndDownloadData(context.Background(), satellite, apikey, passphrase, | |
"my-first-bucket", "foo/bar/baz", []byte("one fish two fish red fish blue fish")) | |
if err != nil { | |
fmt.Println("error:", err) | |
} | |
fmt.Println("success!") | |
} | |
// UploadAndDownloadData uploads the specified data to the specified key in the | |
// specified bucket, using the specified Satellite, API key, and passphrase. | |
func UploadAndDownloadData(ctx context.Context, | |
satelliteAddress, apiKey, passphrase, bucketName, uploadKey string, | |
dataToUpload []byte) error { | |
// Request access grant to the satellite with the API key and passphrase. | |
myConfig := uplink.Config{ | |
DialContext: func(ctx context.Context, network, address string) (net.Conn, error) { | |
return &jsConn{ | |
ip: "127.0.0.1", | |
port: "10000", | |
}, nil | |
}, | |
} | |
access, err := myConfig.RequestAccessWithPassphrase(ctx, satelliteAddress, apiKey, passphrase) | |
if err != nil { | |
return fmt.Errorf("could not request access grant: %v", err) | |
} | |
/* | |
access, err := uplink.RequestAccessWithPassphrase(ctx, satelliteAddress, apiKey, passphrase) | |
if err != nil { | |
return fmt.Errorf("could not request access grant: %v", err) | |
} | |
*/ | |
// Open up the Project we will be working with. | |
project, err := uplink.OpenProject(ctx, access) | |
if err != nil { | |
return fmt.Errorf("could not open project: %v", err) | |
} | |
defer project.Close() | |
// Ensure the desired Bucket within the Project is created. | |
_, err = project.EnsureBucket(ctx, bucketName) | |
if err != nil { | |
return fmt.Errorf("could not ensure bucket: %v", err) | |
} | |
// Intitiate the upload of our Object to the specified bucket and key. | |
upload, err := project.UploadObject(ctx, bucketName, uploadKey, nil) | |
if err != nil { | |
return fmt.Errorf("could not initiate upload: %v", err) | |
} | |
// Copy the data to the upload. | |
buf := bytes.NewBuffer(dataToUpload) | |
_, err = io.Copy(upload, buf) | |
if err != nil { | |
_ = upload.Abort() | |
return fmt.Errorf("could not upload data: %v", err) | |
} | |
// Commit the uploaded object. | |
err = upload.Commit() | |
if err != nil { | |
return fmt.Errorf("could not commit uploaded object: %v", err) | |
} | |
// Initiate a download of the same object again | |
download, err := project.DownloadObject(ctx, bucketName, uploadKey, nil) | |
if err != nil { | |
return fmt.Errorf("could not open object: %v", err) | |
} | |
defer download.Close() | |
// Read everything from the download stream | |
receivedContents, err := ioutil.ReadAll(download) | |
if err != nil { | |
return fmt.Errorf("could not read data: %v", err) | |
} | |
// Check that the downloaded data is the same as the uploaded data. | |
if !bytes.Equal(receivedContents, dataToUpload) { | |
return fmt.Errorf("got different object back: %q != %q", dataToUpload, receivedContents) | |
} | |
return nil | |
} | |
type jsConn struct { | |
ip string | |
port string | |
} | |
var uint8Array = js.Global().Get("Uint8Array") | |
func (c *jsConn) Read(b []byte) (n int, err error) { | |
fmt.Println("read") | |
retVal := js.Global().Call("socketFunc", 2) | |
fmt.Println("received") | |
fmt.Println(retVal) | |
js.CopyBytesToGo(b, retVal) | |
fmt.Println(b) | |
return retVal.Get("byteLength").Int(), nil | |
} | |
func (c *jsConn) Write(b []byte) (n int, err error) { | |
buf := uint8Array.New(len(b)) | |
js.CopyBytesToJS(buf, b) | |
js.Global().Call("socketWrite", c.ip, c.port, buf) | |
return 0, nil | |
} | |
func (c *jsConn) Close() error { | |
fmt.Println("close") | |
return nil | |
} | |
func (c *jsConn) LocalAddr() net.Addr { | |
fmt.Println("local addr") | |
return &addr{} | |
} | |
func (c *jsConn) RemoteAddr() net.Addr { | |
fmt.Println("remote addr") | |
return &addr{} | |
} | |
func (c *jsConn) SetDeadline(t time.Time) error { | |
fmt.Println("set deadline") | |
return nil | |
} | |
func (c *jsConn) SetReadDeadline(t time.Time) error { | |
fmt.Println("set read deadline") | |
return nil | |
} | |
func (c *jsConn) SetWriteDeadline(t time.Time) error { | |
fmt.Println("set write deadline") | |
return nil | |
} | |
type addr struct { | |
} | |
func (*addr) Network() string { | |
return "" | |
} | |
func (*addr) String() string { | |
return "" | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
console.log("in sockets.js") | |
function socketRead(x) { | |
console.log(socket read) | |
return new Uint8Array([21, 31]); | |
} | |
function socketWrite(ip, port, buf) { | |
console.log("socket write " + buf) | |
chrome.sockets.tcp.create({}, function(createInfo) { | |
chrome.sockets.tcp.connect(createInfo.socketId, | |
ip, port, onConnectedCallback); | |
}); | |
chrome.sockets.tcp.send(socketId, buf, onSentCallback); | |
} | |
function onSentCallback() { | |
console.log("onsentcallback") | |
} | |
function onConnectedCallback() { | |
console.log("onconnectedcallback") | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Copyright 2018 The Go Authors. All rights reserved. | |
// Use of this source code is governed by a BSD-style | |
// license that can be found in the LICENSE file. | |
(() => { | |
// Map multiple JavaScript environments to a single common API, | |
// preferring web standards over Node.js API. | |
// | |
// Environments considered: | |
// - Browsers | |
// - Node.js | |
// - Electron | |
// - Parcel | |
if (typeof global !== "undefined") { | |
// global already exists | |
} else if (typeof window !== "undefined") { | |
window.global = window; | |
} else if (typeof self !== "undefined") { | |
self.global = self; | |
} else { | |
throw new Error("cannot export Go (neither global, window nor self is defined)"); | |
} | |
if (!global.require && typeof require !== "undefined") { | |
global.require = require; | |
} | |
if (!global.fs && global.require) { | |
const fs = require("fs"); | |
if (Object.keys(fs) !== 0) { | |
global.fs = fs; | |
} | |
} | |
const enosys = () => { | |
const err = new Error("not implemented"); | |
err.code = "ENOSYS"; | |
return err; | |
}; | |
if (!global.fs) { | |
let outputBuf = ""; | |
global.fs = { | |
constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 }, // unused | |
writeSync(fd, buf) { | |
outputBuf += decoder.decode(buf); | |
const nl = outputBuf.lastIndexOf("\n"); | |
if (nl != -1) { | |
console.log(outputBuf.substr(0, nl)); | |
outputBuf = outputBuf.substr(nl + 1); | |
} | |
return buf.length; | |
}, | |
write(fd, buf, offset, length, position, callback) { | |
if (offset !== 0 || length !== buf.length || position !== null) { | |
callback(enosys()); | |
return; | |
} | |
const n = this.writeSync(fd, buf); | |
callback(null, n); | |
}, | |
chmod(path, mode, callback) { callback(enosys()); }, | |
chown(path, uid, gid, callback) { callback(enosys()); }, | |
close(fd, callback) { callback(enosys()); }, | |
fchmod(fd, mode, callback) { callback(enosys()); }, | |
fchown(fd, uid, gid, callback) { callback(enosys()); }, | |
fstat(fd, callback) { callback(enosys()); }, | |
fsync(fd, callback) { callback(null); }, | |
ftruncate(fd, length, callback) { callback(enosys()); }, | |
lchown(path, uid, gid, callback) { callback(enosys()); }, | |
link(path, link, callback) { callback(enosys()); }, | |
lstat(path, callback) { callback(enosys()); }, | |
mkdir(path, perm, callback) { callback(enosys()); }, | |
open(path, flags, mode, callback) { callback(enosys()); }, | |
read(fd, buffer, offset, length, position, callback) { callback(enosys()); }, | |
readdir(path, callback) { callback(enosys()); }, | |
readlink(path, callback) { callback(enosys()); }, | |
rename(from, to, callback) { callback(enosys()); }, | |
rmdir(path, callback) { callback(enosys()); }, | |
stat(path, callback) { callback(enosys()); }, | |
symlink(path, link, callback) { callback(enosys()); }, | |
truncate(path, length, callback) { callback(enosys()); }, | |
unlink(path, callback) { callback(enosys()); }, | |
utimes(path, atime, mtime, callback) { callback(enosys()); }, | |
}; | |
} | |
if (!global.process) { | |
global.process = { | |
getuid() { return -1; }, | |
getgid() { return -1; }, | |
geteuid() { return -1; }, | |
getegid() { return -1; }, | |
getgroups() { throw enosys(); }, | |
pid: -1, | |
ppid: -1, | |
umask() { throw enosys(); }, | |
cwd() { throw enosys(); }, | |
chdir() { throw enosys(); }, | |
} | |
} | |
if (!global.crypto) { | |
const nodeCrypto = require("crypto"); | |
global.crypto = { | |
getRandomValues(b) { | |
nodeCrypto.randomFillSync(b); | |
}, | |
}; | |
} | |
if (!global.performance) { | |
global.performance = { | |
now() { | |
const [sec, nsec] = process.hrtime(); | |
return sec * 1000 + nsec / 1000000; | |
}, | |
}; | |
} | |
if (!global.TextEncoder) { | |
global.TextEncoder = require("util").TextEncoder; | |
} | |
if (!global.TextDecoder) { | |
global.TextDecoder = require("util").TextDecoder; | |
} | |
// End of polyfills for common API. | |
const encoder = new TextEncoder("utf-8"); | |
const decoder = new TextDecoder("utf-8"); | |
global.Go = class { | |
constructor() { | |
this.argv = ["js"]; | |
this.env = {}; | |
this.exit = (code) => { | |
if (code !== 0) { | |
console.warn("exit code:", code); | |
} | |
}; | |
this._exitPromise = new Promise((resolve) => { | |
this._resolveExitPromise = resolve; | |
}); | |
this._pendingEvent = null; | |
this._scheduledTimeouts = new Map(); | |
this._nextCallbackTimeoutID = 1; | |
const setInt64 = (addr, v) => { | |
this.mem.setUint32(addr + 0, v, true); | |
this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true); | |
} | |
const getInt64 = (addr) => { | |
const low = this.mem.getUint32(addr + 0, true); | |
const high = this.mem.getInt32(addr + 4, true); | |
return low + high * 4294967296; | |
} | |
const loadValue = (addr) => { | |
const f = this.mem.getFloat64(addr, true); | |
if (f === 0) { | |
return undefined; | |
} | |
if (!isNaN(f)) { | |
return f; | |
} | |
const id = this.mem.getUint32(addr, true); | |
return this._values[id]; | |
} | |
const storeValue = (addr, v) => { | |
const nanHead = 0x7FF80000; | |
if (typeof v === "number" && v !== 0) { | |
if (isNaN(v)) { | |
this.mem.setUint32(addr + 4, nanHead, true); | |
this.mem.setUint32(addr, 0, true); | |
return; | |
} | |
this.mem.setFloat64(addr, v, true); | |
return; | |
} | |
if (v === undefined) { | |
this.mem.setFloat64(addr, 0, true); | |
return; | |
} | |
let id = this._ids.get(v); | |
if (id === undefined) { | |
id = this._idPool.pop(); | |
if (id === undefined) { | |
id = this._values.length; | |
} | |
this._values[id] = v; | |
this._goRefCounts[id] = 0; | |
this._ids.set(v, id); | |
} | |
this._goRefCounts[id]++; | |
let typeFlag = 0; | |
switch (typeof v) { | |
case "object": | |
if (v !== null) { | |
typeFlag = 1; | |
} | |
break; | |
case "string": | |
typeFlag = 2; | |
break; | |
case "symbol": | |
typeFlag = 3; | |
break; | |
case "function": | |
typeFlag = 4; | |
break; | |
} | |
this.mem.setUint32(addr + 4, nanHead | typeFlag, true); | |
this.mem.setUint32(addr, id, true); | |
} | |
const loadSlice = (addr) => { | |
const array = getInt64(addr + 0); | |
const len = getInt64(addr + 8); | |
return new Uint8Array(this._inst.exports.mem.buffer, array, len); | |
} | |
const loadSliceOfValues = (addr) => { | |
const array = getInt64(addr + 0); | |
const len = getInt64(addr + 8); | |
const a = new Array(len); | |
for (let i = 0; i < len; i++) { | |
a[i] = loadValue(array + i * 8); | |
} | |
return a; | |
} | |
const loadString = (addr) => { | |
const saddr = getInt64(addr + 0); | |
const len = getInt64(addr + 8); | |
return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len)); | |
} | |
const timeOrigin = Date.now() - performance.now(); | |
this.importObject = { | |
go: { | |
// Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters) | |
// may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported | |
// function. A goroutine can switch to a new stack if the current stack is too small (see morestack function). | |
// This changes the SP, thus we have to update the SP used by the imported function. | |
// func wasmExit(code int32) | |
"runtime.wasmExit": (sp) => { | |
const code = this.mem.getInt32(sp + 8, true); | |
this.exited = true; | |
delete this._inst; | |
delete this._values; | |
delete this._goRefCounts; | |
delete this._ids; | |
delete this._idPool; | |
this.exit(code); | |
}, | |
// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32) | |
"runtime.wasmWrite": (sp) => { | |
const fd = getInt64(sp + 8); | |
const p = getInt64(sp + 16); | |
const n = this.mem.getInt32(sp + 24, true); | |
fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n)); | |
}, | |
// func resetMemoryDataView() | |
"runtime.resetMemoryDataView": (sp) => { | |
this.mem = new DataView(this._inst.exports.mem.buffer); | |
}, | |
// func nanotime1() int64 | |
"runtime.nanotime1": (sp) => { | |
setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000); | |
}, | |
// func walltime1() (sec int64, nsec int32) | |
"runtime.walltime1": (sp) => { | |
const msec = (new Date).getTime(); | |
setInt64(sp + 8, msec / 1000); | |
this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true); | |
}, | |
// func scheduleTimeoutEvent(delay int64) int32 | |
"runtime.scheduleTimeoutEvent": (sp) => { | |
const id = this._nextCallbackTimeoutID; | |
this._nextCallbackTimeoutID++; | |
this._scheduledTimeouts.set(id, setTimeout( | |
() => { | |
this._resume(); | |
while (this._scheduledTimeouts.has(id)) { | |
// for some reason Go failed to register the timeout event, log and try again | |
// (temporary workaround for https://github.com/golang/go/issues/28975) | |
console.warn("scheduleTimeoutEvent: missed timeout event"); | |
this._resume(); | |
} | |
}, | |
getInt64(sp + 8) + 1, // setTimeout has been seen to fire up to 1 millisecond early | |
)); | |
this.mem.setInt32(sp + 16, id, true); | |
}, | |
// func clearTimeoutEvent(id int32) | |
"runtime.clearTimeoutEvent": (sp) => { | |
const id = this.mem.getInt32(sp + 8, true); | |
clearTimeout(this._scheduledTimeouts.get(id)); | |
this._scheduledTimeouts.delete(id); | |
}, | |
// func getRandomData(r []byte) | |
"runtime.getRandomData": (sp) => { | |
crypto.getRandomValues(loadSlice(sp + 8)); | |
}, | |
// func finalizeRef(v ref) | |
"syscall/js.finalizeRef": (sp) => { | |
const id = this.mem.getUint32(sp + 8, true); | |
this._goRefCounts[id]--; | |
if (this._goRefCounts[id] === 0) { | |
const v = this._values[id]; | |
this._values[id] = null; | |
this._ids.delete(v); | |
this._idPool.push(id); | |
} | |
}, | |
// func stringVal(value string) ref | |
"syscall/js.stringVal": (sp) => { | |
storeValue(sp + 24, loadString(sp + 8)); | |
}, | |
// func valueGet(v ref, p string) ref | |
"syscall/js.valueGet": (sp) => { | |
const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16)); | |
sp = this._inst.exports.getsp(); // see comment above | |
storeValue(sp + 32, result); | |
}, | |
// func valueSet(v ref, p string, x ref) | |
"syscall/js.valueSet": (sp) => { | |
Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32)); | |
}, | |
// func valueDelete(v ref, p string) | |
"syscall/js.valueDelete": (sp) => { | |
Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16)); | |
}, | |
// func valueIndex(v ref, i int) ref | |
"syscall/js.valueIndex": (sp) => { | |
storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16))); | |
}, | |
// valueSetIndex(v ref, i int, x ref) | |
"syscall/js.valueSetIndex": (sp) => { | |
Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24)); | |
}, | |
// func valueCall(v ref, m string, args []ref) (ref, bool) | |
"syscall/js.valueCall": (sp) => { | |
try { | |
const v = loadValue(sp + 8); | |
const m = Reflect.get(v, loadString(sp + 16)); | |
const args = loadSliceOfValues(sp + 32); | |
const result = Reflect.apply(m, v, args); | |
sp = this._inst.exports.getsp(); // see comment above | |
storeValue(sp + 56, result); | |
this.mem.setUint8(sp + 64, 1); | |
} catch (err) { | |
storeValue(sp + 56, err); | |
this.mem.setUint8(sp + 64, 0); | |
} | |
}, | |
// func valueInvoke(v ref, args []ref) (ref, bool) | |
"syscall/js.valueInvoke": (sp) => { | |
try { | |
const v = loadValue(sp + 8); | |
const args = loadSliceOfValues(sp + 16); | |
const result = Reflect.apply(v, undefined, args); | |
sp = this._inst.exports.getsp(); // see comment above | |
storeValue(sp + 40, result); | |
this.mem.setUint8(sp + 48, 1); | |
} catch (err) { | |
storeValue(sp + 40, err); | |
this.mem.setUint8(sp + 48, 0); | |
} | |
}, | |
// func valueNew(v ref, args []ref) (ref, bool) | |
"syscall/js.valueNew": (sp) => { | |
try { | |
const v = loadValue(sp + 8); | |
const args = loadSliceOfValues(sp + 16); | |
const result = Reflect.construct(v, args); | |
sp = this._inst.exports.getsp(); // see comment above | |
storeValue(sp + 40, result); | |
this.mem.setUint8(sp + 48, 1); | |
} catch (err) { | |
storeValue(sp + 40, err); | |
this.mem.setUint8(sp + 48, 0); | |
} | |
}, | |
// func valueLength(v ref) int | |
"syscall/js.valueLength": (sp) => { | |
setInt64(sp + 16, parseInt(loadValue(sp + 8).length)); | |
}, | |
// valuePrepareString(v ref) (ref, int) | |
"syscall/js.valuePrepareString": (sp) => { | |
const str = encoder.encode(String(loadValue(sp + 8))); | |
storeValue(sp + 16, str); | |
setInt64(sp + 24, str.length); | |
}, | |
// valueLoadString(v ref, b []byte) | |
"syscall/js.valueLoadString": (sp) => { | |
const str = loadValue(sp + 8); | |
loadSlice(sp + 16).set(str); | |
}, | |
// func valueInstanceOf(v ref, t ref) bool | |
"syscall/js.valueInstanceOf": (sp) => { | |
this.mem.setUint8(sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0); | |
}, | |
// func copyBytesToGo(dst []byte, src ref) (int, bool) | |
"syscall/js.copyBytesToGo": (sp) => { | |
const dst = loadSlice(sp + 8); | |
const src = loadValue(sp + 32); | |
if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) { | |
this.mem.setUint8(sp + 48, 0); | |
return; | |
} | |
const toCopy = src.subarray(0, dst.length); | |
dst.set(toCopy); | |
setInt64(sp + 40, toCopy.length); | |
this.mem.setUint8(sp + 48, 1); | |
}, | |
// func copyBytesToJS(dst ref, src []byte) (int, bool) | |
"syscall/js.copyBytesToJS": (sp) => { | |
const dst = loadValue(sp + 8); | |
const src = loadSlice(sp + 16); | |
if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) { | |
this.mem.setUint8(sp + 48, 0); | |
return; | |
} | |
const toCopy = src.subarray(0, dst.length); | |
dst.set(toCopy); | |
setInt64(sp + 40, toCopy.length); | |
this.mem.setUint8(sp + 48, 1); | |
}, | |
"debug": (value) => { | |
console.log(value); | |
}, | |
} | |
}; | |
} | |
async run(instance) { | |
this._inst = instance; | |
this.mem = new DataView(this._inst.exports.mem.buffer); | |
this._values = [ // JS values that Go currently has references to, indexed by reference id | |
NaN, | |
0, | |
null, | |
true, | |
false, | |
global, | |
this, | |
]; | |
this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id | |
this._ids = new Map([ // mapping from JS values to reference ids | |
[0, 1], | |
[null, 2], | |
[true, 3], | |
[false, 4], | |
[global, 5], | |
[this, 6], | |
]); | |
this._idPool = []; // unused ids that have been garbage collected | |
this.exited = false; // whether the Go program has exited | |
// Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory. | |
let offset = 4096; | |
const strPtr = (str) => { | |
const ptr = offset; | |
const bytes = encoder.encode(str + "\0"); | |
new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes); | |
offset += bytes.length; | |
if (offset % 8 !== 0) { | |
offset += 8 - (offset % 8); | |
} | |
return ptr; | |
}; | |
const argc = this.argv.length; | |
const argvPtrs = []; | |
this.argv.forEach((arg) => { | |
argvPtrs.push(strPtr(arg)); | |
}); | |
argvPtrs.push(0); | |
const keys = Object.keys(this.env).sort(); | |
keys.forEach((key) => { | |
argvPtrs.push(strPtr(`${key}=${this.env[key]}`)); | |
}); | |
argvPtrs.push(0); | |
const argv = offset; | |
argvPtrs.forEach((ptr) => { | |
this.mem.setUint32(offset, ptr, true); | |
this.mem.setUint32(offset + 4, 0, true); | |
offset += 8; | |
}); | |
this._inst.exports.run(argc, argv); | |
if (this.exited) { | |
this._resolveExitPromise(); | |
} | |
await this._exitPromise; | |
} | |
_resume() { | |
if (this.exited) { | |
throw new Error("Go program has already exited"); | |
} | |
this._inst.exports.resume(); | |
if (this.exited) { | |
this._resolveExitPromise(); | |
} | |
} | |
_makeFuncWrapper(id) { | |
const go = this; | |
return function () { | |
const event = { id: id, this: this, args: arguments }; | |
go._pendingEvent = event; | |
go._resume(); | |
return event.result; | |
}; | |
} | |
} | |
if ( | |
global.require && | |
global.require.main === module && | |
global.process && | |
global.process.versions && | |
!global.process.versions.electron | |
) { | |
if (process.argv.length < 3) { | |
console.error("usage: go_js_wasm_exec [wasm binary] [arguments]"); | |
process.exit(1); | |
} | |
const go = new Go(); | |
go.argv = process.argv.slice(2); | |
go.env = Object.assign({ TMPDIR: require("os").tmpdir() }, process.env); | |
go.exit = process.exit; | |
WebAssembly.instantiate(fs.readFileSync(process.argv[2]), go.importObject).then((result) => { | |
process.on("exit", (code) => { // Node.js exits if no event handler is pending | |
if (code === 0 && !go.exited) { | |
// deadlock, make Go print error and stack traces | |
go._pendingEvent = { id: 0 }; | |
go._resume(); | |
} | |
}); | |
return go.run(result.instance); | |
}).catch((err) => { | |
console.error(err); | |
process.exit(1); | |
}); | |
} | |
})(); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment