// Callback is the callback, used to update the progress bar as remote.cache
// downloads
func (cb *CacheCallback) Callback(par *dnode.Partial) {
type Progress struct {
Progress int `json:progress`
Error kite.Error `json:error`
}
// TODO: Why is this an array from Klient? How can this be written cleaner?
ps := []Progress{{}}
par.MustUnmarshal(&ps)
p := ps[0]
cb.Log.Debug("CacheCallback Progress: %#v", p)
if p.Error.Message != "" {
cb.doneErr <- p.Error
}
cb.Bar.Set(p.Progress)
// TODO: Disable the callback here, so that it's impossible to double call
// the progress after competion - to avoid weird/bad UX and errors.
if p.Progress == 100 {
cb.doneErr <- nil
}
}
func (s *Server) SetSize(d *dnode.Partial) {
args := d.MustSliceOfLength(2)
x := args[0].MustFloat64()
y := args[1].MustFloat64()
err := s.client.ResizeExecTTY(s.Session, int(y), int(x))
if err != nil {
fmt.Println("error resizing", err)
}
}
// Input is called when some text is written to the terminal.
func (s *Server) Input(d *dnode.Partial) {
data := d.MustSliceOfLength(1)[0].MustString()
if s.inputHook != nil {
s.inputHook()
}
// There is no need to protect the Write() with a mutex because
// Kite Library guarantees that only one message is processed at a time.
s.in.Write([]byte(data))
}
// newRequest returns a new *Request from the method and arguments passed.
func (c *Client) newRequest(method string, args *dnode.Partial) (*Request, func(interface{}, *Error)) {
// Parse dnode method arguments: [options]
var options callOptions
args.One().MustUnmarshal(&options)
// Notify the handlers registered with Kite.OnFirstRequest().
if _, ok := c.session.(*sockjsclient.WebsocketSession); !ok {
c.firstRequestHandlersNotified.Do(func() {
c.m.Lock()
c.Kite = options.Kite
c.m.Unlock()
c.LocalKite.callOnFirstRequestHandlers(c)
})
}
request := &Request{
ID: utils.RandomString(16),
Method: method,
Args: options.WithArgs,
LocalKite: c.LocalKite,
Client: c,
Auth: options.Auth,
Context: cache.NewMemory(),
}
// Call response callback function, send back our response
callFunc := func(result interface{}, err *Error) {
if options.ResponseCallback.Caller == nil {
return
}
// Only argument to the callback.
response := Response{
Result: result,
Error: err,
}
if err := options.ResponseCallback.Call(response); err != nil {
c.LocalKite.Log.Error(err.Error())
}
}
return request, callFunc
}
func (r *termHandler) Output(d *dnode.Partial) {
data := d.MustSliceOfLength(1)[0].MustString()
r.output <- data
}
// ControlSequence is called when a non-printable key is pressed on the terminal.
func (s *Server) ControlSequence(d *dnode.Partial) {
data := d.MustSliceOfLength(1)[0].MustString()
s.controlSequence.Write([]byte(data))
}
func (s *Server) SetSize(d *dnode.Partial) {
args := d.MustSliceOfLength(2)
x := args[0].MustFloat64()
y := args[1].MustFloat64()
s.setSize(x, y)
}