EDIT: No error occurs in firefox. This only seems to occur in Chrome.
I am trying to get a web client connected to a WebRTC SFU, and simply send some audio in Opus format.
Here is the client code:
https://codesandbox.io/s/webrtc-test-20w7v?file=/src/App.tsx
The server code takes in an SDP and creates an answer :
// SDPHandler handles webrtc peer connection attempts
func (api API) SDPHandler(c echo.Context) error {
ctx := c.(hm.HarmonyContext)
body, err := ioutil.ReadAll(ctx.Request().Body)
if err != nil {
return ctx.NoContent(http.StatusUnprocessableEntity)
}
m := webrtc.MediaEngine{}
m.RegisterCodec(webrtc.NewRTPOpusCodec(webrtc.DefaultPayloadTypeOpus, 90000))
mediaAPI := webrtc.NewAPI(webrtc.WithMediaEngine(m))
offer := webrtc.SessionDescription{}
if err := json.Unmarshal(body, &offer); err != nil {
return ctx.NoContent(http.StatusBadRequest)
}
peerConnection, err := mediaAPI.NewPeerConnection(api.peerConnectionConfig)
if err != nil {
fmt.Println("error making peer connection", err)
return ctx.NoContent(http.StatusInternalServerError)
}
if _, err := peerConnection.AddTransceiverFromKind(webrtc.RTPCodecTypeAudio); err != nil {
fmt.Println("error adding transceiver", err)
return ctx.NoContent(http.StatusInternalServerError)
}
peerConnection.OnTrack(api.OnTrackStart(peerConnection))
if err := peerConnection.SetRemoteDescription(offer); err != nil {
fmt.Println("error setting remote description", err)
return ctx.NoContent(http.StatusInternalServerError)
}
answer, err := peerConnection.CreateAnswer(nil)
if err != nil {
fmt.Println("error making answer", err)
return ctx.NoContent(http.StatusInternalServerError)
}
if err := peerConnection.SetLocalDescription(answer); err != nil {
fmt.Println("error setting local description", err)
return ctx.NoContent(http.StatusInternalServerError)
}
return ctx.JSON(http.StatusOK, answer)
}
When I try to create a session, I have receive the following error:
Failed to execute 'setRemoteDescription' on 'RTCPeerConnection': Session error code: ERROR_CONTENT. Session error description: Failed to set remote audio description send parameters for m-section with mid='0'.
Any ideas on what the issue with my code is?
Related
I am currently trying to deploy another app on GAE using a Google Cloud SQL instance. I already have 2 services running on there with the same setup also using a Cloudsql instance. However, when I am trying to connect to Cloudsql from my newest service, I am getting a "driver: bad connection" error and I can not figure out why. I am using the _ "github.com/go-sql-driver/mysql" driver as follows:
var (
DB_INSTANCE *sql.DB
)
...
configFile := GetConfig()
user := configFile.DatabaseReaderHost.DatabaseUser
password := configFile.DatabaseReaderHost.DatabasePassword
dbName := configFile.DatabaseReaderHost.DatabaseName
connectionName := "project-id:region:instance-name"
if appengine.IsDevAppServer() {
db, err := sql.Open("mysql", fmt.Sprintf("%s:%s#tcp(%s:%s)/%s?parseTime=true",
user,
password,
configFile.DatabaseReaderHost.DatabaseHost,
configFile.DatabaseReaderHost.DatabasePort,
dbName))
if err != nil {
panic(err)
}
DB_INSTANCE = db
return nil
} else {
dbn, err := sql.Open("mysql", fmt.Sprintf("%s:%s#cloudsql(%s)/%s", user, password, connectionName, dbName))
if err != nil {
panic(err)
}
DB_INSTANCE = dbn
return nil
}
What I noticed is that the connection to the Cloudsql instance seems to be established since the above code is not what produces the error, but my test query agains the database.
func TestDatabaseHandler(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
var name string
err := DB_INSTANCE.QueryRow("SELECT name FROM names WHERE id = ?", 1).Scan(&name)
if err != nil {
if err == sql.ErrNoRows {
PrintSingleResponseJson(w, "error", fmt.Sprintf("no rows found"))
} else {
Log(r, fmt.Sprintf("Could not connect to database: %v", err))
PrintSingleResponseJson(w, "error", fmt.Sprintf("could not connect to database: %s", err))
}
return
}
PrintSingleResponseJson(w, "success", fmt.Sprintf("%s", name))
}
I appreciate all help.
I've created a Go API and deploy but when i see the logs there is no Println and no response is send to the client
the main:
func main() {
http.HandleFunc("/v1/", handler)
appengine.Main()
}
func handler(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
http.Error(w, "not allowed", http.StatusMethodNotAllowed)
return
}
...
}
the yaml file:
runtime: go
api_version: go1.8
handlers:
- url: /.*
script: _go_app
the url that i'm accessing:
myapp.appspot.com/v1/param
(what is this _go_app?)
the problem is that if i pass a "POST" request the error works just fine, but if i make a valid request the response take forever.
full code: https://goplay.space/#yiIp42FKzzj
In AppEngine you must use the AppEngine logger, passing in the context from the request.
Example from the godoc:
c := appengine.NewContext(r)
query := &log.Query{
AppLogs: true,
Versions: []string{"1"},
}
for results := query.Run(c); ; {
record, err := results.Next()
if err == log.Done {
log.Infof(c, "Done processing results")
break
}
if err != nil {
log.Errorf(c, "Failed to retrieve next log: %v", err)
break
}
log.Infof(c, "Saw record %v", record)
}
I've got a push task queue in a Go App Engine application. When we try to enqueue tasks in testing for whatever reason the tasks always return 404.
Our app.yaml:
runtime: go
api_version: go1.9
handlers:
- url: /worker/.*
script: _go_app
login: admin
- url: /.*
script: _go_app
The actual task invocation:
func Handler(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
t := taskqueue.NewPOSTTask("/worker", map[string][]string{"key": {"val"}})
_, err := taskqueue.Add(ctx, t, "")
if err != nil {
log.Errorf(ctx, "Failed to add task");
}
fmt.Fprintf(w, "Success");
}
A still-incomplete handler, but it exists!
func Worker(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
log.Infof(ctx, "Worker succeeded")
}
and finally, proof that we actually added the path to our router:
func init() {
http.HandleFunc("/", Handler)
http.HandleFunc("/worker", Worker)
}
When we actually run tests, we always get the following logging output:
INFO 2018-05-03 09:51:11,794 module.py:846] default: "POST /worker HTTP/1.1" 404 19
WARNING 2018-05-03 09:51:11,794 taskqueue_stub.py:2149] Task � failed to execute. This task will retry in 0.100 seconds
INFO 2018-05-03 09:51:11,897 module.py:846] default: "POST /worker HTTP/1.1" 404 19
WARNING 2018-05-03 09:51:11,897 taskqueue_stub.py:2149] Task � failed to execute. This task will retry in 0.200 seconds
INFO 2018-05-03 09:51:12,101 module.py:846] default: "POST /worker HTTP/1.1" 404 19
WARNING 2018-05-03 09:51:12,101 taskqueue_stub.py:2149] Task � failed to execute. This task will retry in 0.400 seconds
Note that the /worker endpoint returns 302 when I try to ping it via an API client like Paw, so the route seems to have been configured correctly. The 404 only arises when I try to run things in a test.
Why is this returning 404? I've tried running tests around the example push queue in their documentation have run into the same issue there - is there some sort of missing configuration flag I'm failing to pass to goapp?
I've pushed up a GitHub repo with a minimal replicable example here
The order for running goapp is top-bottom but you need to be specific in your app.yaml. In your case this will works:
package main
import (
"fmt"
"net/http"
"google.golang.org/appengine"
"google.golang.org/appengine/log"
"google.golang.org/appengine/taskqueue"
)
func Handler(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
t := taskqueue.NewPOSTTask("/worker", map[string][]string{"key": {"val"}})
_, err := taskqueue.Add(ctx, t, "")
if err != nil {
log.Errorf(ctx, "Failed to add task")
}
fmt.Fprintf(w, "Success")
}
func Worker(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
log.Infof(ctx, "Worker succeeded")
}
func init() {
http.HandleFunc("/", Handler)
http.HandleFunc("/worker", Worker)
}
For this you need to map url like:
runtime: go
api_version: go1.9
handlers:
- url: /worker
script: _go_app
login: admin
- url: /.*
script: _go_app
The result is:
See that worker is running two times. This is ocurring because GET /favicon.ico is entering in GET /.* mapping. So this is only details for you!
UPDATE (05/14/2018):
In your test you use aetest.NewInstance(), that runs dev_appserver.py in ioutil.TempDir("", "appengine-aetest"), that writes your own main.go and app.yaml. See above in instance_vm.go:
i.appDir, err = ioutil.TempDir("", "appengine-aetest")
if err != nil {
return err
}
defer func() {
if err != nil {
os.RemoveAll(i.appDir)
}
}()
err = os.Mkdir(filepath.Join(i.appDir, "app"), 0755)
if err != nil {
return err
}
err = ioutil.WriteFile(filepath.Join(i.appDir, "app", "app.yaml"), []byte(i.appYAML()), 0644)
if err != nil {
return err
}
err = ioutil.WriteFile(filepath.Join(i.appDir, "app", "stubapp.go"), []byte(appSource), 0644)
if err != nil {
return err
}
//... others codes
const appYAMLTemplate = `
application: %s
version: 1
runtime: go
api_version: go1
vm: true
handlers:
- url: /.*
script: _go_app
`
const appSource = `
package main
import "google.golang.org/appengine"
func main() { appengine.Main() }
`
So you need to create your own server-instance. This is a way:
//out buffer
var out bytes.Buffer
//start server
c := exec.Command("goapp", "serve") //default port=8080, adminPort=8000
c.Stdout = &out
c.Stderr = &out
c.Start()
defer c.Process.Kill()
//delay to wait server is completed
time.Sleep(10 * time.Second)
//... others codes
//quit server
quitReq, err := http.NewRequest("GET", "http://localhost:8000/quit", nil)
_, err := client.Do(quitReq)
if err != nil {
fmt.Errorf("GET /quit handler error: %v", err)
}
To test your Handler function do:
//create request (testing Handler func)
req, err := http.NewRequest("GET", "http://localhost:8080/", nil)
if err != nil {
t.Fatal(err.Error())
}
//do GET
client := http.DefaultClient
resp, err := client.Do(req)
if err != nil {
t.Error(err)
}
defer resp.Body.Close()
//delay to wait for the worker to execute
time.Sleep(10 * time.Second)
To retrieve the result and test it:
//read response
b, _ := ioutil.ReadAll(resp.Body)
resp_content := string(b)
//checking
if !strings.Contains(resp_content, "Handler Success") {
t.Errorf("Handler not working")
}
//log server content
logserver := out.String()
if !strings.Contains(logserver, "Worker succeeded") {
t.Errorf("Worker not working")
}
//log response
t.Logf(logserver)
The result is:
UPDATE: Link for Github: https://github.com/ag-studies/go-appengine-sample
Hope this help!!
Your handlers pattern is /worker/.* but you are issuing tasks to /worker.
You should do 1 of the following:
Either change pattern to /worker.* or just /worker
Or issue request(s) to /worker/ or /worker/some-task-name.
Hey im trying to implement a resumable upload to cloud storage .
But im getting a Status:"401 Unauthorized", StatusCode:401
And im assuming that it`s something with the bearer but i can't figure out another way to send the bearer Token.
I've been able to delete files with the GetClinet method.
func GetClinet(c endpoints.Context) *http.Client {
cli := &http.Client{
Transport: &oauth2.Transport{
Source: google.AppEngineTokenSource(c, storage.ScopeReadWrite),
Base: &urlfetch.Transport{Context: c},
},
}
return cli
}
client := GetClinet(con)
url := "https://storage.googleapis.com/bucketName/file.txt"
b := r.Header.Get("Authorization") //parse the bearer from user request
r, err = http.NewRequest("POST", url, nil)
r.Header.Add("Content-Type", "text/plain")
r.Header.Add("Content-Length", "0")
r.Header.Add("x-goog-resumable", "start")
r.Header.Add("Authorization", b)
resp, err := client.Do(r)
I'm having similar difficulties, not sure if your situation is the same as mine. My goal is to
User client uploads meta-data to my server
Server authenticates and stores in DB
Server asks Google Cloud Storage for resumabale upload url
Server returns url to client
Client uses url to upload media to GCS
I'm getting 401 unauthorized returns too. Maybe I'm not setting the headers correctly? or the storage.SignedURL doesn't handle resumable uploads properly...?
I've been able to upload files using a Service Account PEM file
func setGcsFile(c context.Context, fileId string, content []byte) error {
expiration := time.Now().Add(time.Second * 30) //expire in 30 seconds
data, err = ioutil.ReadFile(serviceAccountPEMFilename)
if err != nil {
fmt.Printf("error: %v", err)
panic(err)
}
log.Debugf(c, "Getting upload url")
opts := &storage.SignedURLOptions{
GoogleAccessID: googleAccessID,
PrivateKey: data,
Method: "PUT",
Expires: expiration,
}
putURL, err := storage.SignedURL(bucket, fileId, opts)
if err != nil {
log.Debugf(c, "%v", err)
return err
}
log.Debugf(c, "PUT URL : %v\n", putURL)
client := urlfetch.Client(c)
req, err := http.NewRequest("PUT", putURL, bytes.NewBuffer(content))
res, err := client.Do(req)
if err != nil {
log.Debugf(c, "%v", err)
return err
}
res.Body.Close()
log.Debugf(c, "Response Code: %s\n", res.Status)
return nil
}
I'm thinking about pulling and modifying the storage.SignedURL function next.
My following code
package inqzincrm
import (
"github.com/gorilla/pat"
"github.com/gorilla/sessions"
"net/http"
)
var store = sessions.NewCookieStore([]byte("X12h8v6BZC4QJl53KfNLshtr85gkC5OZ"), []byte("X12h8vasdf6BZC4QJl53KfNLshtr85gk"))
func init() {
r := pat.New()
r.Get("/", Home)
http.Handle("/", r)
}
and in handler,
package inqzincrm
import (
"appengine"
"html/template"
"net/http"
)
var aTmplt = template.Must(template.ParseFiles(
"inqzincrm/templates/base.html",
"inqzincrm/templates/index.html",
))
func Home(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
session, err := store.Get(r, "x")
c.Infof("HOST: %s", r.Host)
if session.IsNew {
session.Options.Domain = r.Host
session.Options.Path = "/"
session.Options.MaxAge = 0
session.Options.HttpOnly = false
session.Options.Secure = false
}
if err != nil {
c.Infof("Error getting session: %v", err)
}
c.Infof("Requested URL: %v", session.Values["foo"])
session.Values["foo"] = "asdf"
if err := aTmplt.ExecuteTemplate(w, "index.html", nil); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
session.Save(r, w)
}
do not set any cookie on browser side. how ever result and err are nil indicating no problem with the functions.
How I should debug further ?
I am using Ubuntu 64 bit, Google App Engine, Go with Gorilla tool kit.
Have a look at my answer to a previous question here.
In short form:
import (
"github.com/gorilla/sessions"
"net/http"
)
// Authorization Key
var authKey = []byte("somesecret")
// Encryption Key
var encKey = []byte("someothersecret")
var store = sessions.NewCookieStore(authKey, encKey)
func initSession(r *http.Request) *sessions.Session {
session, _ := store.Get(r, "my_cookie") // Don't ignore the error in real code
if session.IsNew { //Set some cookie options
session.Options.Domain = "example.org"
session.Options.MaxAge = 0
session.Options.HttpOnly = false
session.Options.Secure = true
}
return session
}
Then, in your handlers:
func ViewPageHandler(w http.ResponseWriter, r *http.Request) {
session := initSession(r)
session.Values["page"] = "view"
session.Save(r, w)
....
Your code seems to do the same thing, so without more of an example I can't see any problem with it. I can say that the example I've posted is (very slightly modified) from a working server.
the code session.save() should come before template execution code. it has been mentioned no where. but that was the whole mistake.