Example #1
0
func (this *DynamicHandler) ServeContextOptions(context *web.Context, origin map[string]string) {
	router.SetHeaderOrigin(context.Response, context.Request, origin)

	var (
		header  http.Header                = context.Response.Header()
		ctrlmgr *controller.ControlManager = this.GetControlManager(context)
		mlist   []string                   = ctrlmgr.AvailableMethodsList()
	)

	mliststr := strings.Join(mlist, ", ")
	allow := "HEAD, OPTIONS"

	if mliststr != "" {
		allow += ", " + mliststr
	}

	header.Set("Allow", allow)
	header.Set("Access-Control-Allow-Methods", mliststr)
	context.Response.WriteHeader(200)
}
Example #2
0
func (this *WebSocketHandler) ServeContextHTTP(context *web.Context) {
	var ctrlmgr *controller.ControlManager = controller.NewControlManager(context, this.ctrl, "_")

	if err := context.ToWebSocket(nil, nil); err != nil {
		context.RaiseAppError("Unable to upgrade to websocket: " + err.Error())
	}

	defer func() {
		if err := recover(); err != nil {
			log.Println(err)
		}
	}()

	ctrlmgr.Prepare()

	var (
		ctrler  = ctrlmgr.Controller()
		listen  = &methMeta{method: ctrler.MethodByName("Listen_")}
		methods = make(map[string]*methMeta)
		meth    *methMeta
		ok      bool
		t       reflect.Type
	)

	if listen.method.IsValid() {
		t = listen.method.Type()
		if t.NumIn() != 2 || t.In(0) != intType || t.In(1) != retbType {
			listen.method = reflect.Value{}
		}
	}
	listen.rettype = getRetType(listen.method, t)
	listen.isvalid = listen.method.IsValid()

	for {
		msgT, p, err := context.WebSocket.ReadMessage()

		if err != nil {
			if m := ctrler.MethodByName("Error_"); m.IsValid() && m.Type().NumIn() == 1 &&
				m.Type().In(0) == errType {

				m.Call([]reflect.Value{reflect.ValueOf(err)})
			}

			break
		}

		if this.allowcmd && msgT == websocket.TextMessage && len(p) > 0 && p[0] == '/' {
			args := WSArgs(argSplit.Split(strings.TrimSpace(string(p[1:len(p)])), -1))
			cmd := strings.Replace(strings.Title(args[0]), "-", "_", -1)

			if cmd[len(cmd)-1] != '_' && validCmd.MatchString(cmd) {
				args = args[1:len(args)]

				if meth, ok = methods[cmd]; !ok {
					m := ctrler.MethodByName(cmd)

					if m.IsValid() {
						t = m.Type()
						if t.NumIn() != 1 || t.In(0) != argsType {
							m = reflect.Value{}
						}
						meth = &methMeta{
							method:  m,
							rettype: getRetType(m, t),
							isvalid: m.IsValid(),
						}
					} else {
						meth = &methMeta{
							method:  m,
							rettype: 0,
							isvalid: false,
						}
					}

					methods[cmd] = meth
				}

				if meth.isvalid {
					write(meth, context.WebSocket, meth.method.Call([]reflect.Value{reflect.ValueOf(args)}))
					continue
				}
			}
		}

		if listen.isvalid {
			write(listen, context.WebSocket,
				listen.method.Call([]reflect.Value{reflect.ValueOf(msgT), reflect.ValueOf(p)}))
		}
	}
}