Пример #1
0
func (ei *EntityIndex) Verify() []error {
	var errs []error
	for k, v := range ei.byid {
		if k != v.Id() {
			errs = append(errs, fmt.Error("Key %v does not match entity id %v for entity %v", k, v.Id(), v.Name()))
		}
	}
	for k, v := range ei.byname {
		if k != v.Name() {
			errs = append(errs, fmt.Error("Key %v does not match entity name %v for entity %v", k, v.Name(), v.Id()))
		}
	}
	return errs
}
Пример #2
0
func (bus *Bus) startListener() (net.Listener, error) {
	bus.Lock()
	defer bus.Unlock()

	if bus.listener != nil {
		return nil, fmt.Error("Bus already listening")
	}

	l, err := net.Listen(bus.config.Net, fmt.String("%v:%v", bus.config.Address, bus.config.Port))
	if err != nil {
		return nil, fmt.Error("Error starting listener: %v", err)
	}
	bus.listener = l
	return l, nil
}
Пример #3
0
func (g *Geometry) AddLayout(l Layout) error {
	if g.LayoutExists(l.Id()) {
		return fmt.Error("layout %v already exists", l.Id())
	}
	g.layouts[l.Id()] = l
	return nil
}
Пример #4
0
func (node *chanTransport) Receive() (*Msg, error) {
	msg, ok := <-node.rx
	if ok {
		return msg, nil
	}
	return nil, fmt.Error("EOF")
}
Пример #5
0
func (client *Client) Receive() (*Msg, error) {
	msg, err := client.transport.Receive()
	if err != nil {
		client.bus.onClientError(client, fmt.Error("Receive: %v", err))
	}
	return msg, err
}
Пример #6
0
func (client *Client) Send(msg *Msg) error {
	err := client.transport.Send(msg)
	if err != nil {
		client.bus.onClientError(client, fmt.Error("Send: %v", err))
		return err
	}
	return nil
}
Пример #7
0
func (ctx *context) stop() error {
	if ctx.status != ctxStarted {
		return fmt.Error("Service %v not started", ctx.Name())
	}
	ctx.status = ctxStopping
	err := ctx.service.Stop(ctx)
	ctx.status = ctxStopped
	return err
}
Пример #8
0
func (r *contextList) Get(name string) (*context, error) {
	l := r.GetAll()
	for _, ctx := range l {
		if ctx.name == name {
			return ctx, nil
		}
	}
	return nil, fmt.Error("No context with name %v", name)
}
Пример #9
0
Файл: bus.go Проект: resc/core
func (bus *bus) Subscribe(topic string, h Handler) Closer {
	if h == nil {
		panic(fmt.Error("h is nil"))
	}
	return bus.subscribe(&handler{
		id:      bus.id,
		topic:   topic,
		handler: h,
	})
}
Пример #10
0
func (node *chanTransport) Send(msg *Msg) (err error) {
	defer func() {
		e := recover()
		if e != nil {
			err = fmt.Error("%v", e)
		}
	}()
	node.tx <- msg
	return
}
Пример #11
0
func (node *chanTransport) Close() (err error) {
	defer func() {
		e := recover()
		if e != nil {
			err = fmt.Error("%v", e)
		}
	}()
	close(node.rx)
	close(node.tx)
	return
}
Пример #12
0
func (ei *EntityIndex) CreateId(name string) (int, string, error) {
	if ei.NameExists(name) {
		return -1, "", fmt.Error("Name %v already exists")
	}
	id := ei.nextid
	for ; ei.IdExists(id); id++ {
	}
	ei.nextid = id + 1
	ei.byid[id] = nil
	ei.byname[name] = nil
	return id, name, nil
}
Пример #13
0
func parseFile(r *bufio.Reader) (*Config, error) {
	cfg := newConfig()
	s := cfg.section("")
	lineNo := 0
	for {
		lineNo++

		line, err := r.ReadString('\n')
		if err == io.EOF {
			return cfg, nil
		} else if err != nil {
			return nil, err
		}

		line = strings.TrimSpace(line)
		if isEmpty(line) || isComment(line) {
			continue
		}

		if name, ok := trySectionHeader(line); ok {
			if _, isdup := cfg.sections[name]; isdup {
				return nil, fmt.Error("Duplicate section header [%v] at line %v", name, lineNo)
			} else {
				s = newNestedSection(cfg.sections[""])
				s.set("__name__", name)
				cfg.sections[name] = s
			}
			continue
		}

		if key, val, ok := tryKeyValuePair(line); ok {
			s.set(key, val)
			continue
		}

		return nil, fmt.Error("Error parsing configuration at line %v", lineNo)
	}
}
Пример #14
0
func (c *carrier) Resize(size int) error {
	l := len(c.children)
	if size == l {
		return nil // nothing to do...
	}

	if !canResize(c.children, size) {
		return fmt.Error("Resizing would drop entities")
	}

	old := c.children
	c.children = make([]Entity, size)
	copy(c.children, old)
	return nil
}
Пример #15
0
func (ctx *context) start() error {
	if ctx.status != ctxStopped {
		err := fmt.Error("Service %v not stopped", ctx.Name())
		ctx.log.Printf("Error starting service: %v: %v", ctx.Name(), err)
		return err
	}
	ctx.status = ctxStarting
	err := ctx.service.Start(ctx)
	if err != nil {
		ctx.log.Printf("Error starting service %v: %v", ctx.Name(), err)
		ctx.status = ctxStopped
		return err
	}
	ctx.status = ctxStarted
	return nil
}
Пример #16
0
func FromFile(path string) (*Config, error) {
	path, err := filepath.Abs(path)
	if err != nil {
		return nil, err
	}

	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}

	defer f.Close()
	if cfg, err := FromReader(f); err != nil {
		return nil, fmt.Error("Error parsing file %v: %v", path, err)
	} else {
		return cfg, nil
	}
}
Пример #17
0
func (client *Client) pumpMessages() {
	client.routines.Add(1)
	defer func() {
		recovered := recover()
		client.routines.Done()
		if recovered != nil {
			err := fmt.Error("pumpMessages: %v", recovered)
			client.bus.onClientError(client, err)
		}
		client.Close()
	}()

	for client.running() {
		msg, err := client.Receive()
		if err != nil {
			return
		}
		client.bus.Handle(client, msg)
	}
}
Пример #18
0
func FromArgs() (*Config, error) {
	set := flag.NewFlagSet("cfg", flag.ContinueOnError)
	var rawCfgArgs argcfg
	set.Var(&rawCfgArgs, "cfg", "comma-separated list of configuration key-value pairs")
	err := set.Parse(os.Args[1:])
	if err != nil {
		return nil, err
	}

	cfg := newConfig()
	for _, rawkv := range rawCfgArgs {
		kv := strings.TrimSpace(rawkv)
		if key, val, ok := tryKeyValuePair(kv); ok {
			cfg.set("", key, val)
		} else {
			return nil, fmt.Error("Invalid commandline key-value pair: '%v'", kv)
		}
	}
	return cfg, nil
}
Пример #19
0
func (m *Model) AddStaticCarrier(name string, x, y, rows, cols int) (Carrier, error) {
	if m.entityExists(name) {
		return nil, fmt.Error("Entity with name %v already exists", name)
	}

	c, err := m.newCarrier(name, rows*cols)
	if err != nil {
		return nil, err
	}

	carrierLayout := m.geometry.newGridLayout(rows, cols, m.gridSize())
	carrierLayout.id = c.Id()
	m.geometry.AddLayout(carrierLayout)

	b := m.grid.getBoundingBox(x, y, rows, cols)
	m.sitelayout.set(c.Index(), *b)

	m.site.add(c)
	return c, nil
}
Пример #20
0
func (s *Server) Refresh(c *Command) {
	fmt.Printline("Received a refresh")
	cmd := new(Refresh)
	err := json.Unmarshal(c.MsgBody, cmd)
	if err != nil {
		s.InvalidCommand(c, err)
		return
	}
	m, ok := s.models[cmd.ModelName]
	if !ok {
		s.InvalidCommand(c, fmt.Error("Unknown model %v", cmd.ModelName))
		return
	}

	s.Respond(c, &ModelCreated{
		Name:  m.Name(),
		Rows:  m.grid.rows,
		Cols:  m.grid.cols,
		GridX: m.grid.size.W,
		GridY: m.grid.size.L,
	})

}
Пример #21
0
func (msg *GetConfig) Wait() (Config, error) {
	if cfg, ok := <-msg.config; ok {
		return cfg, nil
	}
	return nil, fmt.Error("Config %v not found", msg.name)
}
Пример #22
0
func (core *core) Handle(msg Msg) {
	switch msg := msg.(type) {

	case *registerService:
		if msg.service == nil {
			return
		}
		core.ctx.Log().Printf("Registering service %v", msg.service.Name())
		core.Register(msg.service)
		msg.Success()

	case *unregisterService:
		core.ctx.Log().Printf("Unregistering service %v", msg.Name)
		core.ctx.Run(func() {
			msg.Error(fmt.Error("Not implemented"))
		})

	case *startService:
		core.ctx.Log().Printf("Starting service %v", msg.Name)
		core.ctx.Run(func() {
			ctx, err := core.contexts.Get(msg.Name)
			if err == nil {
				ctx.receive(msg)
			} else {
				msg.Error(err)
			}
		})

	case *stopService:
		core.ctx.Run(func() {
			ctx, err := core.contexts.Get(msg.Name)
			if err == nil {
				core.ctx.Log().Printf("Stopping service %v", msg.Name)
				ctx.receive(msg)
			} else {
				msg.Error(err)
			}
		})

	case *startAllServices:
		core.ctx.Log().Print("Starting all services")
		core.ctx.Run(func() {
			contexts := core.contexts.GetAll()
			for _, ctx := range contexts {
				if autostart, ok := ctx.Cfg().Bool("autostart"); ok && autostart {
					core.ctx.Log().Printf("Starting service %v", ctx.Name())
					result := NewResult()
					ctx.receive(&startService{Name: ctx.Name(), Result: result})
					err := result.Wait()
					if err != nil {
						msg.Error(err)
						return
					}
				}
			}
			msg.Success()
		})

	case *listServices:
		core.ctx.Log().Print("Listing services")
		contexts := core.contexts.GetAll()
		list := make([]ServiceState, 0, len(contexts))
		timestamp := time.Now()
		for _, ctx := range contexts {
			list = append(list, ServiceState{
				Id:        ctx.id,
				Name:      ctx.name,
				Status:    ctx.status,
				Timestamp: timestamp,
			})
		}
		msg.Result <- list

	case *stopAllServices:
		core.ctx.Log().Print("Stopping all services")
		core.ctx.Run(func() {
			contexts := core.contexts.GetAll()
			lastindex := len(contexts) - 1
			for i := range contexts {
				ctx := contexts[lastindex-i]
				result := NewResult()
				core.ctx.Log().Printf("Stopping service %v", ctx.Name())
				ctx.receive(&stopService{Name: ctx.Name(), Result: result})
				err := result.Wait()
				if err != nil {
					msg.Error(err)
					return
				}
			}
			msg.Success()
		})

	default:
		core.ctx.Log().Printf("Unhandled message %T %+v", msg, msg)
	}
}