예제 #1
0
func (h *handlerManager) DeleteApplication(ctx context.Context, in *pb.ApplicationIdentifier) (*empty.Empty, error) {
	if err := in.Validate(); err != nil {
		return nil, errors.Wrap(err, "Invalid Application Identifier")
	}
	ctx, claims, err := h.validateTTNAuthAppContext(ctx, in.AppId)
	if err != nil {
		return nil, err
	}
	if !claims.AppRight(in.AppId, rights.AppSettings) {
		return nil, errors.NewErrPermissionDenied(`No "settings" rights to application`)
	}
	_, err = h.handler.applications.Get(in.AppId)
	if err != nil {
		return nil, err
	}

	// Get and delete all devices for this application
	devices, err := h.handler.devices.ListForApp(in.AppId)
	if err != nil {
		return nil, err
	}
	for _, dev := range devices {
		_, err = h.deviceManager.DeleteDevice(ctx, &pb_lorawan.DeviceIdentifier{AppEui: &dev.AppEUI, DevEui: &dev.DevEUI})
		if err != nil {
			return nil, errors.Wrap(errors.FromGRPCError(err), "Broker did not delete device")
		}
		err = h.handler.devices.Delete(dev.AppID, dev.DevID)
		if err != nil {
			return nil, err
		}
	}

	// Delete the Application
	err = h.handler.applications.Delete(in.AppId)
	if err != nil {
		return nil, err
	}

	token, _ := api.TokenFromContext(ctx)
	err = h.handler.Discovery.RemoveAppID(in.AppId, token)
	if err != nil {
		h.handler.Ctx.WithField("AppID", in.AppId).WithError(errors.FromGRPCError(err)).Warn("Could not unregister Application from Discovery")
	}

	return &empty.Empty{}, nil
}
예제 #2
0
// ValidateTTNAuthContext gets a token from the context and validates it
func (c *Component) ValidateTTNAuthContext(ctx context.Context) (*claims.Claims, error) {
	token, err := api.TokenFromContext(ctx)
	if err != nil {
		return nil, err
	}

	if c.TokenKeyProvider == nil {
		return nil, errors.NewErrInternal("No token provider configured")
	}

	claims, err := claims.FromToken(c.TokenKeyProvider, token)
	if err != nil {
		return nil, errors.NewErrPermissionDenied(err.Error())
	}

	return claims, nil
}
예제 #3
0
func (h *handlerManager) RegisterApplication(ctx context.Context, in *pb.ApplicationIdentifier) (*empty.Empty, error) {
	if err := in.Validate(); err != nil {
		return nil, errors.Wrap(err, "Invalid Application Identifier")
	}
	ctx, claims, err := h.validateTTNAuthAppContext(ctx, in.AppId)
	if err != nil {
		return nil, err
	}
	if !claims.AppRight(in.AppId, rights.AppSettings) {
		return nil, errors.NewErrPermissionDenied(`No "settings" rights to application`)
	}
	app, err := h.handler.applications.Get(in.AppId)
	if err != nil && errors.GetErrType(err) != errors.NotFound {
		return nil, err
	}
	if app != nil {
		return nil, errors.NewErrAlreadyExists("Application")
	}

	err = h.handler.applications.Set(&application.Application{
		AppID: in.AppId,
	})
	if err != nil {
		return nil, err
	}

	token, _ := api.TokenFromContext(ctx)
	err = h.handler.Discovery.AddAppID(in.AppId, token)
	if err != nil {
		h.handler.Ctx.WithField("AppID", in.AppId).WithError(err).Warn("Could not register Application with Discovery")
	}

	_, err = h.handler.ttnBrokerManager.RegisterApplicationHandler(ctx, &pb_broker.ApplicationHandlerRegistration{
		AppId:     in.AppId,
		HandlerId: h.handler.Identity.Id,
	})
	if err != nil {
		h.handler.Ctx.WithField("AppID", in.AppId).WithError(err).Warn("Could not register Application with Broker")
	}

	return &empty.Empty{}, nil

}
예제 #4
0
func TestClient(t *testing.T) {
	a := New(t)

	ctx := GetLogger(t, "Monitor Client")
	rand.Seed(time.Now().UnixNano())
	port := rand.Intn(1000) + 10000
	go startExampleServer(2, port)

	{
		client, err := NewClient(ctx, fmt.Sprintf("localhost:%d", port))
		a.So(err, ShouldBeNil)
		a.So(client.IsConnected(), ShouldBeTrue)
		a.So(client.Reopen(), ShouldBeNil)
		a.So(client.IsConnected(), ShouldBeTrue)
		a.So(client.Close(), ShouldBeNil)
	}

	{
		client, _ := NewClient(ctx, fmt.Sprintf("localhost:%d", port))
		gtw := client.GatewayClient("dev")
		a.So(gtw.IsConfigured(), ShouldBeFalse)
		gtw.SetToken("SOME.AWESOME.JWT")
		a.So(gtw.IsConfigured(), ShouldBeTrue)

		ctx := gtw.(*gatewayClient).Context()
		id, _ := api.IDFromContext(ctx)
		a.So(id, ShouldEqual, "dev")
		token, _ := api.TokenFromContext(ctx)
		a.So(token, ShouldEqual, "SOME.AWESOME.JWT")

		a.So(client.Close(), ShouldBeNil)
	}

	{
		client, _ := NewClient(ctx, fmt.Sprintf("localhost:%d", port))
		defer client.Close()
		gtw := client.GatewayClient("dev")

		err := gtw.SendStatus(&gateway.Status{})
		a.So(err, ShouldBeNil)

		gtw.SetToken("SOME.AWESOME.JWT")

		// The first two statuses are OK
		for i := 0; i < 2; i++ {
			err = gtw.SendStatus(&gateway.Status{})
			a.So(err, ShouldBeNil)
		}

		// The next one will cause an error on the test server
		err = gtw.SendStatus(&gateway.Status{})
		time.Sleep(10 * time.Millisecond)

		// Then, we are going to buffer 10 statuses locally
		for i := 0; i < 10; i++ {
			err = gtw.SendStatus(&gateway.Status{})
			a.So(err, ShouldBeNil)
		}

		// After which statuses will get dropped
		err = gtw.SendStatus(&gateway.Status{})
		a.So(err, ShouldNotBeNil)

		time.Sleep(100 * time.Millisecond)
	}

	{
		client, _ := NewClient(ctx, fmt.Sprintf("localhost:%d", port))
		defer client.Close()
		gtw := client.GatewayClient("dev")

		err := gtw.SendUplink(&router.UplinkMessage{})
		a.So(err, ShouldBeNil)

		gtw.SetToken("SOME.AWESOME.JWT")

		// The first two messages are OK
		for i := 0; i < 2; i++ {
			err = gtw.SendUplink(&router.UplinkMessage{})
			a.So(err, ShouldBeNil)
		}

		// The next one will cause an error on the test server
		err = gtw.SendUplink(&router.UplinkMessage{})
		time.Sleep(10 * time.Millisecond)

		// Then, we are going to buffer 10 messages locally
		for i := 0; i < 10; i++ {
			err = gtw.SendUplink(&router.UplinkMessage{})
			a.So(err, ShouldBeNil)
		}

		// After which messages will get dropped
		err = gtw.SendUplink(&router.UplinkMessage{})
		a.So(err, ShouldNotBeNil)

		time.Sleep(100 * time.Millisecond)
	}

	{
		client, _ := NewClient(ctx, fmt.Sprintf("localhost:%d", port))
		defer client.Close()
		gtw := client.GatewayClient("dev")

		err := gtw.SendDownlink(&router.DownlinkMessage{})
		a.So(err, ShouldBeNil)

		gtw.SetToken("SOME.AWESOME.JWT")

		// The first two messages are OK
		for i := 0; i < 2; i++ {
			err = gtw.SendDownlink(&router.DownlinkMessage{})
			a.So(err, ShouldBeNil)
		}

		// The next one will cause an error on the test server
		err = gtw.SendDownlink(&router.DownlinkMessage{})
		time.Sleep(10 * time.Millisecond)

		// Then, we are going to buffer 10 messages locally
		for i := 0; i < 10; i++ {
			err = gtw.SendDownlink(&router.DownlinkMessage{})
			a.So(err, ShouldBeNil)
		}

		// After which messages will get dropped
		err = gtw.SendDownlink(&router.DownlinkMessage{})
		a.So(err, ShouldNotBeNil)

		time.Sleep(100 * time.Millisecond)
	}

}