Exemplo n.º 1
0
func main() {
	r := runner.New(Name)
	if err := r.Init(); err != nil {
		log.Fatal(err)
	}

	if r.Kite == nil {
		r.Log.Fatal("couldnt init kite")
	}

	// remove QOS, we want to consume all the messages from RMQ
	if err := r.Bongo.Broker.Sub.(*broker.Consumer).Consumer.QOS(0); err != nil {
		r.Log.Fatal("couldnt remove the QOS %# v", err)
	}

	appConfig := config.MustRead(r.Conf.Path)

	// init mongo connection
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	// init with defaults & ensure expireAt index
	mongoCache := cache.NewMongoCacheWithTTL(modelhelper.Mongo.Session, cache.StartGC(), cache.MustEnsureIndexExpireAt())
	defer mongoCache.StopGC()

	handler := collaboration.New(r.Log, mongoCache, appConfig, r.Kite)
	r.SetContext(handler)
	// only listen and operate on collaboration ping messages that are fired by the handler
	r.Register(models.Ping{}).On(collaboration.FireEventName).Handle((*collaboration.Controller).Ping)
	r.Listen()
	r.Wait()
}
Exemplo n.º 2
0
func TestValidate(t *testing.T) {
	r := runner.New("test")
	if err := r.Init(); err != nil {
		t.Fatalf("couldnt start bongo %s", err.Error())
	}
	defer r.Close()

	// init mongo connection
	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	Convey("while testing Validate", t, func() {
		Convey("From field of Mail struct should not be empty, otherwise return err", func() {
			m := &Mail{}
			err := m.Validate()
			So(err, ShouldNotBeNil)
			So(err, ShouldEqual, ErrFromFieldIsNotSet)
		})

		Convey("TextBody field of Mail struct should not be empty, otherwise return err", func() {
			m := &Mail{From: "*****@*****.**"}
			err := m.Validate()
			So(err, ShouldNotBeNil)
			So(err, ShouldEqual, ErrTextBodyIsNotSet)
		})

		Convey("returns nil if Mail struct is set ", func() {
			m := &Mail{From: "*****@*****.**", TextBody: "Some text parapraph"}
			So(m.Validate(), ShouldBeNil)
		})
	})
}
Exemplo n.º 3
0
func withTestServer(t *testing.T, f func(url string)) {
	const workerName = "pingtest"

	r := runner.New(workerName)
	if err := r.Init(); err != nil {
		t.Fatal(err)
	}

	c := config.MustRead(r.Conf.Path)
	// init mongo connection
	modelhelper.Initialize(c.Mongo)
	defer modelhelper.Close()

	port := tests.GetFreePort()
	mc := mux.NewConfig(workerName, "localhost", port)
	mc.Debug = r.Conf.Debug
	m := mux.New(mc, r.Log, r.Metrics)

	AddHandlers(m)

	m.Listen()

	go r.Listen()

	f(fmt.Sprintf("http://localhost:%s", port))

	if err := r.Close(); err != nil {
		t.Fatalf("server close errored: %s", err.Error())
	}

	// shutdown server
	m.Close()
}
Exemplo n.º 4
0
func main() {
	r := runner.New(Name)
	if err := r.Init(); err != nil {
		log.Fatal(err)
	}

	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	segmentExporter := eventexporter.NewSegmentIOExporter(appConfig.Segment, QueueLength)
	datadogExporter := eventexporter.NewDatadogExporter(r.DogStatsD)

	// TODO
	// we are gonna add this line into the multiexporter
	// firstly, we need to make sure our json data satisfy druid's data specs
	// druidExporter := eventexporter.NewDruidExporter(appConfig.DruidHost)
	// exporter := eventexporter.NewMultiExporter(segmentExporter, datadogExporter, druidExporter)

	exporter := eventexporter.NewMultiExporter(segmentExporter, datadogExporter)

	constructor := emailsender.New(exporter, r.Log, appConfig)
	r.ShutdownHandler = constructor.Close

	r.SetContext(constructor)

	r.Register(emailsender.Mail{}).On(emailsender.SendEmailEventName).Handle((*emailsender.Controller).Process)

	r.Listen()
	r.Wait()
}
Exemplo n.º 5
0
func (cmd *GroupDelete) Run(ctx context.Context) error {
	modelhelper.Initialize(envMongoURL())
	defer modelhelper.Close()

	entries, err := cmd.listEntries(ctx, cmd.filter())
	if err != nil {
		return err
	}
	items := make([]Item, len(entries))
	for i, entry := range entries {
		items[i] = &Instance{
			SoftlayerID: entry.ID,
			Domain:      entry.Tags["koding-domain"],
			Username:    entry.Tags["koding-user"],
		}
	}
	// TODO(rjeczalik): It's not possible to concurrently delete domains due to:
	//
	//   ERROR    could not delete domain "ukhscbd6fee9.kloudctl.dev.koding.io":
	//   PriorRequestNotComplete: The request was rejected because Route 53 was
	//   still processing a prior request.\n\tstatus code: 400, request id:
	//   c8248760-b2e5-11e5-9b7d-33010efc6afe"
	//
	cmd.GroupThrottler.throttle = 1
	return cmd.RunItems(ctx, items)
}
Exemplo n.º 6
0
func (cmd *GroupFixDomain) Run(ctx context.Context) error {
	modelhelper.Initialize(envMongoURL())
	defer modelhelper.Close()

	merr := new(multierror.Error)
	users := cmd.values

	for len(users) > 0 {
		var batch []string
		var records []*dnsclient.Record
		var ids []bson.ObjectId
		n := min(len(users), 100)
		batch, users = users[:n], users[n:]

		DefaultUi.Info(fmt.Sprintf("checking %d records...", n))

		for _, user := range batch {
			rec, id, err := cmd.fixDomain(user)
			if err != nil {
				merr = multierror.Append(merr, err)
				continue
			}

			if cmd.dry {
				if rec == nil {
					merr = multierror.Append(merr, fmt.Errorf("domain for %q is ok", user))
				} else {
					merr = multierror.Append(merr, fmt.Errorf("domain for %q is going to be upserted without -dry: %q", user, rec.Name))
				}

				continue
			}

			if rec == nil {
				continue
			}

			records = append(records, rec)
			ids = append(ids, id)
		}

		if len(records) == 0 {
			continue
		}

		DefaultUi.Info(fmt.Sprintf("going to upsert %d domains", len(records)))

		// upsert domains
		if err := cmd.dns.UpsertRecords(records...); err != nil {
			merr = multierror.Append(merr, err)
		}

		// update domains
		if err := cmd.update(records, ids); err != nil {
			merr = multierror.Append(merr, err)
		}
	}

	return merr.ErrorOrNil()
}
Exemplo n.º 7
0
func main() {
	r := runner.New(Name)
	if err := r.Init(); err != nil {
		fmt.Println(err)
		return
	}

	// init mongo connection
	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	r.SetContext(realtime.New(r.Bongo.Broker.MQ, r.Log))
	r.Register(models.ChannelMessage{}).OnUpdate().Handle((*realtime.Controller).MessageUpdated)
	r.Register(models.MessageReply{}).OnCreate().Handle((*realtime.Controller).MessageReplySaved)
	r.Register(models.MessageReply{}).OnDelete().Handle((*realtime.Controller).MessageReplyDeleted)
	r.Register(models.ChannelMessageList{}).OnCreate().Handle((*realtime.Controller).MessageListSaved)
	r.Register(models.ChannelMessageList{}).OnUpdate().Handle((*realtime.Controller).ChannelMessageListUpdated)
	r.Register(models.ChannelMessageList{}).OnDelete().Handle((*realtime.Controller).MessageListDeleted)
	r.Register(models.ParticipantEvent{}).On(models.ChannelParticipant_Removed_From_Channel_Event).Handle((*realtime.Controller).ChannelParticipantRemoved)
	r.Register(models.ParticipantEvent{}).On(models.ChannelParticipant_Added_To_Channel_Event).Handle((*realtime.Controller).ChannelParticipantsAdded)
	r.Register(models.ChannelParticipant{}).OnUpdate().Handle((*realtime.Controller).ChannelParticipantUpdatedEvent)
	r.Register(models.Channel{}).OnDelete().Handle((*realtime.Controller).ChannelDeletedEvent)
	r.Register(models.Channel{}).OnUpdate().Handle((*realtime.Controller).ChannelUpdatedEvent)
	r.Listen()
	r.Wait()
}
Exemplo n.º 8
0
func TestIndexSettingsDefaults(t *testing.T) {
	runner, handler := getTestHandler()
	defer runner.Close()

	appConfig := config.MustRead(runner.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	Convey("given some handler", t, func() {
		err := handler.Init()
		So(err, ShouldBeNil)

		Convey("account email should not be retrievable", func() {
			indexSet, err := handler.indexes.Get(IndexAccounts)
			So(err, ShouldBeNil)

			settings, err := indexSet.Index.GetSettings()
			So(err, ShouldBeNil)

			found := false
			for _, item := range settings.UnretrievableAttributes {
				if item == "email" {
					found = true
				}

			}

			So(found, ShouldBeTrue)
		})
	})
}
Exemplo n.º 9
0
func TestGetIdsFromMailboxHash(t *testing.T) {
	r := runner.New("test")
	if err := r.Init(); err != nil {
		t.Fatalf("couldnt start bongo %s", err.Error())
	}
	defer r.Close()

	// init mongo connection
	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	Convey("while getting ids from mailboxhash", t, func() {

		Convey("returns error if 1.index of mailboxhash doesn't exist", func() {
			m := &Mail{
				MailboxHash: "message.",
			}

			gid, err := m.getIdsFromMailboxHash()
			So(err, ShouldNotBeNil)
			So(gid, ShouldEqual, 0)
		})

		Convey("returns error if 1.index doesn't exist", func() {
			m := &Mail{
				MailboxHash: "message.1234",
			}

			gid, err := m.getIdsFromMailboxHash()
			So(err, ShouldBeNil)
			So(gid, ShouldEqual, 1234)
		})
	})
}
Exemplo n.º 10
0
func main() {
	r := runner.New(Name)
	if err := r.Init(); err != nil {
		fmt.Println(err)
		return
	}

	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	// create a realtime service provider instance.
	pubnub := models.NewPubNub(appConfig.GateKeeper.Pubnub, r.Log)
	defer pubnub.Close()

	mc := mux.NewConfig(Name, appConfig.GateKeeper.Host, appConfig.GateKeeper.Port)
	m := mux.New(mc, r.Log, r.Metrics)

	h := api.NewHandler(pubnub, appConfig, r.Log)

	h.AddHandlers(m)

	// consume messages from RMQ
	// Gatekeeper is not using RMQ, but runner is creating a message queue for
	// each worker.  We need to discard the messages in the queue, otherwise
	// all the messages are piled up
	go r.Listen()

	m.Listen()
	defer m.Close()

	r.Wait()
}
Exemplo n.º 11
0
func TestAccountParticipantAdded(t *testing.T) {
	runner, handler := getTestHandler()
	defer runner.Close()

	// init mongo connection
	appConfig := config.MustRead(runner.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	Convey("given some account", t, func() {
		acc, err := models.CreateAccountInBothDbs()
		So(err, ShouldBeNil)
		So(acc, ShouldNotBeNil)

		tc1 := models.CreateTypedGroupedChannelWithTest(
			acc.Id,
			models.Channel_TYPE_TOPIC,
			models.Channel_KODING_NAME,
		)

		models.AddParticipantsWithTest(tc1.Id, acc.Id)

		cp := &models.ChannelParticipant{
			ChannelId:      tc1.Id,
			AccountId:      acc.Id,
			StatusConstant: models.ChannelParticipant_STATUS_ACTIVE,
		}

		Convey("when the account is already on algolia", func() {
			err := handler.AccountCreated(acc)
			So(err, ShouldBeNil)
			So(doBasicTestForAccount(handler, acc.OldId), ShouldBeNil)

			err = handler.ParticipantCreated(cp)
			So(err, ShouldBeNil)

			So(doBasicTestForAccount(handler, acc.OldId), ShouldBeNil)
			So(makeSureHasTag(handler, acc.OldId, strconv.FormatInt(tc1.Id, 10)), ShouldBeNil)

			Convey("trying to add again should success", func() {
				err = handler.ParticipantCreated(cp)
				So(err, ShouldBeNil)

				So(doBasicTestForAccount(handler, acc.OldId), ShouldBeNil)
				So(makeSureHasTag(handler, acc.OldId, strconv.FormatInt(tc1.Id, 10)), ShouldBeNil)
				So(makeSureTagLen(handler, acc.OldId, 2), ShouldBeNil)
			})
		})

		Convey("when the account is not on algolia", func() {
			err = handler.ParticipantCreated(cp)
			So(err, ShouldBeNil)

			So(doBasicTestForAccount(handler, acc.OldId), ShouldBeNil)
			So(makeSureHasTag(handler, acc.OldId, strconv.FormatInt(tc1.Id, 10)), ShouldBeNil)
			So(makeSureTagLen(handler, acc.OldId, 1), ShouldBeNil)
		})
	})
}
Exemplo n.º 12
0
func initialize() {
	flag.Parse()
	if *flagMongoConn == "" {
		fmt.Printf("Please specify mongo conn string.")
		os.Exit(1)
	}

	helper.Initialize(*flagMongoConn)
}
Exemplo n.º 13
0
func (cmd *GroupList) Run(ctx context.Context) error {
	modelhelper.Initialize(envMongoURL())
	defer modelhelper.Close()

	if cmd.entries {
		return cmd.printEntries(ctx)
	}
	return cmd.printInstances(ctx)
}
Exemplo n.º 14
0
func TestCollaborationSesionEnd(t *testing.T) {
	r := runner.New("collaboration-tests")
	err := r.Init()
	if err != nil {
		panic(err)
	}

	defer r.Close()

	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	Convey("while testing collaboration session end", t, func() {

		Convey("we should be able to create a doc on google drive", func() {
			Convey("we should be able to delete a created doc", func() {
				Convey("deleting an already deleted doc should not give error", func() {
				})
			})
		})

		Convey("trying to delete a non-existing doc should not give error", func() {
		})
	})

	Convey("while pinging collaboration", t, func() {
		// owner
		owner, err := apimodels.CreateAccountInBothDbs()
		So(err, ShouldBeNil)
		So(owner, ShouldNotBeNil)

		groupName := apimodels.RandomGroupName()
		apimodels.CreateTypedGroupedChannelWithTest(
			owner.Id,
			apimodels.Channel_TYPE_GROUP,
			groupName,
		)

		ownerSession, err := modelhelper.FetchOrCreateSession(owner.Nick, groupName)
		So(err, ShouldBeNil)
		So(ownerSession, ShouldNotBeNil)

		Convey("reponse should be success", func() {
			p := &models.Ping{
				AccountId: 1,
				FileId:    "hello",
			}

			res, err := rest.CollaborationPing(p, ownerSession.ClientId)
			So(err, ShouldBeNil)
			So(res, ShouldNotBeNil)
		})
	})
}
Exemplo n.º 15
0
func WithConfiguration(t *testing.T, f func(c *config.Config)) {
	r := runner.New("test")
	if err := r.Init(); err != nil {
		t.Fatal(err.Error())
	}
	defer r.Close()

	c := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(c.Mongo)
	defer modelhelper.Close()

	f(c)
}
Exemplo n.º 16
0
func WithRunner(t *testing.T, f func(*runner.Runner)) {
	r := runner.New("test")
	if err := r.Init(); err != nil {
		t.Fatalf("couldnt start bongo %s", err.Error())
	}
	defer r.Close()

	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	f(r)
}
Exemplo n.º 17
0
func (cmd *GroupStack) Run(ctx context.Context) error {
	modelhelper.Initialize(envMongoURL())
	defer modelhelper.Close()

	var mu sync.Mutex
	var wg sync.WaitGroup
	merr := new(multierror.Error)
	jobs := make(chan string)

	go func() {
		for _, username := range cmd.groupValues.values {
			jobs <- username
		}
		close(jobs)
	}()

	DefaultUi.Info(fmt.Sprintf("processing %d users...", len(cmd.groupValues.values)))

	for range make([]struct{}, cmd.jobs) {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for username := range jobs {
				sd, err := cmd.details(username)
				if err != nil {
					merr = multierror.Append(merr, err)
					continue
				}

				if cmd.rm {
					err = modelhelper.RemoveFromStack(sd)
				} else {
					err = modelhelper.AddToStack(sd)
				}
				if err != nil {
					DefaultUi.Warn(fmt.Sprintf("processing %q user stack failed: %s", username, err))

					mu.Lock()
					merr = multierror.Append(merr, err)
					mu.Unlock()
				} else {
					DefaultUi.Warn(fmt.Sprintf("processed %q user stack", username))
				}
			}
		}()
	}

	wg.Wait()

	return merr.ErrorOrNil()
}
Exemplo n.º 18
0
func (cmd *GroupCreate) Run(ctx context.Context) (err error) {
	modelhelper.Initialize(envMongoURL())
	defer modelhelper.Close()

	var spec *MachineSpec
	if !cmd.dry {
		spec, err = ParseMachineSpec(cmd.file)
	} else {
		spec = &MachineSpec{
			Machine: models.Machine{
				Provider: "softlayer",
				Users: []models.MachineUser{{
					Username: "******",
				}},
				Slug: "softlayer-vm-0",
			},
		}
	}
	if err != nil {
		return err
	}

	var specs []*MachineSpec
	if len(cmd.values) != 0 {
		specs, err = cmd.multipleUserSpecs(spec)
	} else {
		specs, err = cmd.multipleMachineSpecs(spec)
	}
	if len(specs) == 0 {
		if err != nil {
			DefaultUi.Warn(err.Error())
		}
		return errors.New("nothing to build")
	}

	if err != nil {
		DefaultUi.Warn(err.Error())
	}

	items := make([]Item, len(specs))
	for i, spec := range specs {
		items[i] = spec
	}

	if e := cmd.RunItems(ctx, items); e != nil {
		return multierror.Append(err, e).ErrorOrNil()
	}

	return err
}
Exemplo n.º 19
0
func main() {
	r := runner.New(name)
	if err := r.Init(); err != nil {
		log.Fatal(err.Error())
	}

	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	r.SetContext(presence.New(r.Log, appConfig))
	r.Register(presence.Ping{}).On(presence.EventName).Handle((*presence.Controller).Ping)
	r.Listen()
	r.Wait()
}
Exemplo n.º 20
0
func main() {
	r := runner.New(Name)
	if err := r.Init(); err != nil {
		fmt.Println(err)
		return
	}
	defer r.Close()

	// init mongo connection
	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	algolia := algoliasearch.NewClient(
		appConfig.Algolia.AppId,
		appConfig.Algolia.ApiSecretKey,
	)

	// create message handler
	handler := algoliaconnector.New(r.Log, algolia, appConfig.Algolia.IndexSuffix)
	counter := 0
	for b := 0; ; b++ {
		var accounts []models.Account

		err := (&models.Account{}).Some(&accounts, &bongo.Query{
			Pagination: *bongo.NewPagination(100, b*100),
		})
		if err != nil {
			r.Log.Error(err.Error())
			continue
		}

		for _, account := range accounts {
			counter++
			r.Log.Info("[%d]: currently migrating: '%v'", counter, account.Nick)
			if err := handler.AccountUpdated(&account); err != nil {
				r.Log.Error(err.Error())
				continue
			}
		}

		if len(accounts) < 100 {
			break
		}
	}
}
Exemplo n.º 21
0
func main() {
	r := runner.New(Name)
	if err := r.Init(); err != nil {
		log.Fatal(err)
	}

	// init mongo connection
	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	if err := models.DeleteDiffedDBAccounts(); err != nil {
		fmt.Println("error while deleting account that non-existing in mongo", err)
		return
	}

}
Exemplo n.º 22
0
func TestGetSocialIdFromEmail(t *testing.T) {
	r := runner.New("test")
	if err := r.Init(); err != nil {
		t.Fatalf("couldnt start bongo %s", err.Error())
	}
	defer r.Close()

	// init mongo connection
	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	Convey("while getting account id in the mail", t, func() {
		Convey("From fields should be saved in db, otherwise return err", func() {

			m := &Mail{
				From: "mailisnotexist@abo",
			}

			gid, err := m.getSocialIdFromEmail()
			So(err, ShouldNotBeNil)
			So(err, ShouldEqual, ErrEmailIsNotFetched)
			So(gid, ShouldEqual, 0)
		})

		Convey("should not be any error if all is well", func() {

			acc, err := socialapimodels.CreateAccountInBothDbs()
			So(err, ShouldBeNil)

			mongoUser, err := modelhelper.GetUser(acc.Nick)
			So(err, ShouldBeNil)

			m := &Mail{
				From: mongoUser.Email,
			}

			gid, err := m.getSocialIdFromEmail()
			So(err, ShouldBeNil)
			So(gid, ShouldEqual, acc.Id)

		})

	})
}
Exemplo n.º 23
0
func TestCollaborationOperationsDeleteDriveDoc(t *testing.T) {
	r := runner.New("collaboration-DeleteDriveDoc-tests")
	err := r.Init()
	if err != nil {
		panic(err)
	}

	defer r.Close()

	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	// init with defaults
	mongoCache := cache.NewMongoCacheWithTTL(modelhelper.Mongo.Session)
	defer mongoCache.StopGC()

	handler := New(r.Log, mongoCache, appConfig, r.Kite)

	Convey("while testing DeleteDriveDoc", t, func() {
		req := &models.Ping{
			AccountId: 1,
			FileId:    fmt.Sprintf("%d", rand.Int63()),
		}
		Convey("should be able to create the file", func() {
			f, err := createTestFile(handler)
			So(err, ShouldBeNil)
			req.FileId = f.Id

			Convey("should be able to delete the created file", func() {
				err = handler.DeleteDriveDoc(req)
				So(err, ShouldBeNil)
			})

			Convey("if file id is nil response should be nil", func() {
				req := req
				req.FileId = ""
				err = handler.DeleteDriveDoc(req)
				So(err, ShouldBeNil)
			})
		})
	})
}
Exemplo n.º 24
0
func main() {
	r := runner.New(Name)
	if err := r.Init(); err != nil {
		log.Fatal(err)
	}

	appConfig := config.MustRead(r.Conf.Path)

	algolia := algoliasearch.NewClient(appConfig.Algolia.AppId, appConfig.Algolia.ApiSecretKey)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	// create message handler
	handler := algoliaconnector.New(r.Log, algolia, appConfig.Algolia.IndexSuffix)

	index, ok := indexes.(map[string]interface{})
	items, ok := index["items"].([]interface{})
	if !ok {
		return
	}
	for _, item := range items {
		it, ok := item.(map[string]interface{})
		if !ok {
			continue
		}
		updatedAt := it["updatedAt"].(string)
		t, err := time.Parse(time.RFC3339, updatedAt)
		if err != nil {
			fmt.Println("parsing time:", err)
			return
		}

		if t.Before(GetLast60Days()) {
			if _, err := handler.InitAndDeleteIndex(it["name"].(string)); err != nil {
				fmt.Println(err)
				return
			}
		}
	}

	r.Wait()
}
Exemplo n.º 25
0
func TestMailParse(t *testing.T) {
	r := runner.New("test")
	err := r.Init()
	if err != nil {
		panic(err)
	}

	defer r.Close()

	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	Convey("while sending mail", t, func() {

		Convey("reponse should be success", func() {
			acc, err := socialapimodels.CreateAccountInBothDbs()
			So(err, ShouldBeNil)

			c := socialapimodels.CreateChannelWithTest(acc.Id)
			socialapimodels.AddParticipantsWithTest(c.Id, acc.Id)

			cm := socialapimodels.CreateMessage(c.Id, acc.Id, socialapimodels.ChannelMessage_TYPE_POST)
			So(cm, ShouldNotBeNil)

			mongoUser, err := modelhelper.GetUser(acc.Nick)
			So(err, ShouldBeNil)

			p := &models.Mail{
				From:              mongoUser.Email,
				OriginalRecipient: fmt.Sprintf("*****@*****.**", c.Id),
				MailboxHash:       fmt.Sprintf("messageid.%d", cm.Id),
				TextBody:          "Its an example of text message",
				StrippedTextReply: "This one is reply message",
			}

			res, err := rest.MailParse(p)
			So(err, ShouldBeNil)
			So(res, ShouldNotBeNil)
		})
	})
}
Exemplo n.º 26
0
func TestGetAccount(t *testing.T) {
	r := runner.New("test")
	if err := r.Init(); err != nil {
		t.Fatalf("couldnt start bongo %s", err.Error())
	}
	defer r.Close()

	// init mongo connection
	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	Convey("while testing get account", t, func() {
		Convey("returns empty if parameter is invalid", func() {
			acc, err := GetAccount("interestingEmail@somethinglikethat")
			So(err, ShouldNotBeNil)
			So(acc, ShouldBeNil)
		})

		Convey("returns empty if parameter is empty", func() {
			acc, err := GetAccount("")
			So(err, ShouldNotBeNil)
			So(acc, ShouldBeNil)
		})

		Convey("Should return blank if parameter is empty", func() {
			acc, err := socialapimodels.CreateAccountInBothDbs()
			So(err, ShouldBeNil)

			mongoUser, err := modelhelper.GetUser(acc.Nick)
			So(err, ShouldBeNil)

			m := &Mail{
				From: mongoUser.Email,
			}
			ga, err := GetAccount(m.From)
			So(err, ShouldBeNil)
			So(ga, ShouldNotBeNil)
		})

	})
}
Exemplo n.º 27
0
func main() {
	r := runner.New(Name)
	if err := r.Init(); err != nil {
		log.Fatal(err)
	}

	// init mongo connection
	appConfig := config.MustRead(r.Conf.Path)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	r.SetContext(team.NewController(r.Log, appConfig))
	r.Register(models.ChannelParticipant{}).OnCreate().Handle((*team.Controller).HandleParticipant)
	r.Register(models.ChannelParticipant{}).OnUpdate().Handle((*team.Controller).HandleParticipant)
	r.Register(models.ChannelParticipant{}).OnDelete().Handle((*team.Controller).HandleParticipant)
	r.Register(models.Channel{}).OnCreate().Handle((*team.Controller).HandleCreator)
	r.Register(models.Channel{}).OnDelete().Handle((*team.Controller).HandleChannel)
	r.Listen()
	r.Wait()
}
Exemplo n.º 28
0
func main() {
	r := runner.New(Name)
	if err := r.Init(); err != nil {
		log.Fatal(err)
	}

	appConfig := config.MustRead(r.Conf.Path)

	algolia := algoliasearch.NewClient(appConfig.Algolia.AppId, appConfig.Algolia.ApiSecretKey)
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	// create message handler
	handler := algoliaconnector.New(r.Log, algolia, appConfig.Algolia.IndexSuffix)

	if err := handler.DeleteNicksWithQueryBrowseAll(""); err != nil {
		r.Log.Error("Could not remove guest accounts: %s", err)
	}

	r.Wait()
}
Exemplo n.º 29
0
// NewMongoDB looks up environment variables for mongo configuration URL. If
// configuration is found, this function creates a new session and replaces
// modeltesthelper Mongo singleton. If not, fails the test.
//
// Test will Fatal if connection to database is broken.
func NewMongoDB(t *testing.T) *MongoDB {
	var mongoURL string
	for _, mongoEnv := range mongoEnvs {
		if mongoURL = os.Getenv(mongoEnv); mongoURL != "" {
			break
		}
	}

	if mongoURL == "" {
		t.Fatalf("mongodb: one of env variables must be set: %s", strings.Join(mongoEnvs, ", "))
	}

	modelhelper.Initialize(mongoURL)

	m := &MongoDB{DB: modelhelper.Mongo}
	if err := m.DB.Session.Ping(); err != nil {
		t.Fatalf("mongodb: cannot connect to %s: %v", mongoURL, err)
	}

	return m
}
Exemplo n.º 30
0
func main() {
	r := runner.New(Name)
	if err := r.Init(); err != nil {
		log.Fatal(err.Error())
	}

	appConfig := config.MustRead(r.Conf.Path)

	// init mongo connection
	modelhelper.Initialize(appConfig.Mongo)
	defer modelhelper.Close()

	algolia := algoliasearch.NewClient(appConfig.Algolia.AppId, appConfig.Algolia.ApiSecretKey)

	// create message handler
	handler := algoliaconnector.New(r.Log, algolia, appConfig.Algolia.IndexSuffix)
	if err := handler.Init(); err != nil {
		//  this is not a blocker for algoliaconnector worker, we can continue working
		r.Log.Error("Err while init: %s", err.Error())
	}

	r.SetContext(handler)
	r.Register(models.Channel{}).OnCreate().Handle((*algoliaconnector.Controller).ChannelCreated)
	r.Register(models.Channel{}).OnUpdate().Handle((*algoliaconnector.Controller).ChannelUpdated)
	r.Register(models.Account{}).OnCreate().Handle((*algoliaconnector.Controller).AccountCreated)
	r.Register(models.Account{}).OnUpdate().Handle((*algoliaconnector.Controller).AccountUpdated)
	r.Register(models.ChannelMessageList{}).OnCreate().Handle((*algoliaconnector.Controller).MessageListSaved)
	r.Register(models.ChannelMessageList{}).OnDelete().Handle((*algoliaconnector.Controller).MessageListDeleted)
	r.Register(models.ChannelMessage{}).OnUpdate().Handle((*algoliaconnector.Controller).MessageUpdated)

	// participant related events
	r.Register(models.ChannelParticipant{}).OnCreate().Handle((*algoliaconnector.Controller).ParticipantCreated)
	r.Register(models.ChannelParticipant{}).OnUpdate().Handle((*algoliaconnector.Controller).ParticipantUpdated)

	r.Listen()
	r.Wait()
}