func TestSubscription(t *testing.T) {
var s Subscription
var sJSON = []byte(`
{
"id": "5b2e1b6f-b3f7-4a94-8b05-aa441606d886",
"event_type": "test_event_type",
"context": "test_context",
"account_id": "e4f05126-a0e8-437d-94f9-b553c959cdfb",
"timestamp": "2015-07-10T10:50:34.437512Z"
}`)
if err := json.Unmarshal(sJSON, &s); err != nil {
t.Error(err.Error())
}
sAccountID, _ := uuid.FromString("e4f05126-a0e8-437d-94f9-b553c959cdfb")
sID, _ := uuid.FromString("5b2e1b6f-b3f7-4a94-8b05-aa441606d886")
sTime, _ := time.Parse(time.RFC3339, "2015-07-10T10:50:34.437512Z")
cases := []struct {
label, actual, expected interface{}
}{
{"id", s.ID, sID},
{"event type", s.EventType, "test_event_type"},
{"context", s.Context, "test_context"},
{"account id", s.AccountID, sAccountID},
{"created at date", s.CreatedAt, sTime},
}
for _, c := range cases {
if c.actual != c.expected {
t.Errorf("Subscriber %v is %q, but expected %q", c.label, c.actual, c.expected)
}
}
}
func updateRecordWithUserId(input interface{}, fieldNames map[string]bool, id, userId string, session *xorm.Session) (statusCode int, err error) {
if _, err := uuid.FromString(id); err != nil {
return http.StatusBadRequest, errUuidNotValid
}
if _, err := uuid.FromString(userId); err != nil {
return http.StatusBadRequest, errUuidNotValid
}
//convert the fields set to array
array := []string{}
for k, _ := range fieldNames {
array = append(array, k)
}
//update the database
affected, err := session.Where("id = ? and user_id = ?", id, userId).Cols(array...).Update(input)
if err != nil {
return http.StatusInternalServerError, err
}
if affected == 0 {
return http.StatusNotFound, errors.New("The record is not found.")
}
return http.StatusNoContent, nil
}
func PutOAuthUser(mdb *Store, u *pb.OAuthUser) (*pb.OAuthUser, error) {
key, v, err := GetOAuthUser(mdb, u.Provider, u.UserId)
if err != nil {
return nil, err
}
if v != nil {
if u.Uuid != "" && v.Uuid != "" {
uuid1, _ := uuid.FromString(u.Uuid)
uuid2, _ := uuid.FromString(v.Uuid)
if !uuid.Equal(uuid1, uuid2) {
return nil, fmt.Errorf("user mismatch")
}
}
if u.Uuid == "" {
u.Uuid = v.Uuid
}
}
bytes, err := proto.Marshal(u)
if err != nil {
return nil, err
}
// refresh OAuth User info to store
err = mdb.Put(key.Bytes(), bytes)
if err != nil {
return nil, err
}
return u, nil
}
func (t *testSyncerSuite) TestMysqlGTIDSync(c *C) {
t.setupTest(c, mysql.MySQLFlavor)
r, err := t.c.Execute("SELECT @@gtid_mode")
c.Assert(err, IsNil)
modeOn, _ := r.GetString(0, 0)
if modeOn != "ON" {
c.Skip("GTID mode is not ON")
}
r, err = t.c.Execute("SHOW GLOBAL VARIABLES LIKE 'SERVER_UUID'")
c.Assert(err, IsNil)
var masterUuid uuid.UUID
if s, _ := r.GetString(0, 1); len(s) > 0 && s != "NONE" {
masterUuid, err = uuid.FromString(s)
c.Assert(err, IsNil)
}
set, _ := mysql.ParseMysqlGTIDSet(fmt.Sprintf("%s:%d-%d", masterUuid.String(), 1, 2))
s, err := t.b.StartSyncGTID(set)
c.Assert(err, IsNil)
t.testSync(c, s)
}
func toID(param string) uuid.UUID {
val, err := uuid.FromString(param)
if err != nil {
log.Fatal(err)
}
return val
}
func TestUUIDFlakeKey(t *testing.T) {
Convey("Giving key, convert to bytes", t, func() {
id, err := uuid.FromString("c6f8dca8-54f0-11dd-b489-003048343a40")
So(err, ShouldBeNil)
So(hex.EncodeToString(id.Bytes()), ShouldEqual, hex.EncodeToString(id[:16][:]))
fid := flake.Id{}
suffix := hex.EncodeToString(fid[:])
key := NewUUIDFlakeKey(TableFeed, id, fid)
So(key.Len(), ShouldEqual, 36)
uid := "c6f8dca854f011ddb489003048343a40"
So(key.String(), ShouldEqual, "00000001"+uid+suffix)
So(hex.EncodeToString(key.Prefix().Bytes()), ShouldEqual, "00000001"+uid)
So(string(key.Prefix().Bytes()), ShouldEqual, string(key.UUIDKey.Bytes()))
key.UUIDKey.PrefixTable = TableFeedinfo
So(key.String(), ShouldEqual, "00000002"+uid+suffix)
So(hex.EncodeToString(key.Prefix().Bytes()), ShouldEqual, "00000002"+uid)
key.Id[15] = 1
suffix = hex.EncodeToString(key.Id[:])
So(key.String(), ShouldEqual, "00000002"+uid+suffix)
So(hex.EncodeToString(key.Prefix().Bytes()), ShouldEqual, "00000002"+uid)
})
}
func (s *ApiServer) FetchProfile(ctx context.Context, req *pb.ProfileRequest) (*pb.Profile, error) {
uuid1, err := uuid.FromString(req.Uuid)
if err != nil {
return nil, err
}
return store.GetProfileFromUuid(s.mdb, uuid1)
}
// Creates new instance of Worker. Returns error on fail.
func NewWorker() (worker *Worker, err error) {
sock, err := newAsyncRWSocket("unix", flagEndpoint, time.Second*5)
if err != nil {
return
}
logger, err := NewLogger()
if err != nil {
return
}
workerID, _ := uuid.FromString(flagUUID)
disown_timeout := 5 * time.Second
w := Worker{
unpacker: newStreamUnpacker(),
uuid: workerID,
logger: logger,
heartbeat_timer: time.NewTimer(HEARTBEAT_TIMEOUT),
disown_timer: time.NewTimer(disown_timeout),
sessions: make(map[int64](*Request)),
from_handlers: make(chan rawMessage),
socketIO: sock,
fallback: defaultFallbackHandler,
disown_timeout: disown_timeout,
}
w.disown_timer.Stop()
w.handshake()
w.heartbeat()
worker = &w
return
}
// Decode decodes a string according to the alphabet into a uuid.UUID. If s is
// too short, its most significant bits (MSB) will be padded with 0 (zero).
func (b base57) Decode(u string) (uuid.UUID, error) {
str, err := b.stringToNum(u)
if err != nil {
return uuid.Nil, err
}
return uuid.FromString(str)
}
func (s *ApiServer) LikeEntry(ctx context.Context, req *pb.LikeRequest) (*pb.Entry, error) {
entry, err := store.GetEntry(s.rdb, req.Entry)
if err != nil {
return nil, err
}
uuid1, err := uuid.FromString(req.User)
if err != nil {
return nil, err
}
profile, err := store.GetProfileFromUuid(s.mdb, uuid1)
if err != nil || profile == nil {
return nil, err
}
if req.Like {
var key *store.UUIDKey
key, entry, err = store.Like(s.rdb, profile, entry)
if err == nil {
s.spread(key)
}
} else {
entry, err = store.DeleteLike(s.rdb, profile, entry)
}
return entry, err
}
// Delete deletes the work item link category with the given id
// returns NotFoundError or InternalError
func (r *GormWorkItemLinkCategoryRepository) Delete(ctx context.Context, ID string) error {
id, err := satoriuuid.FromString(ID)
if err != nil {
// treat as not found: clients don't know it must be a UUID
return errors.NewNotFoundError("work item link category", ID)
}
var cat = WorkItemLinkCategory{
ID: id,
}
log.Info(ctx, map[string]interface{}{
"pkg": "link",
"wilcID": ID,
}, "Work item link category to delete")
db := r.db.Delete(&cat)
if db.Error != nil {
return errors.NewInternalError(db.Error.Error())
}
if db.RowsAffected == 0 {
return errors.NewNotFoundError("work item link category", id.String())
}
return nil
}
// List runs the list action.
func (c *SpaceIterationsController) List(ctx *app.ListSpaceIterationsContext) error {
spaceID, err := uuid.FromString(ctx.ID)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, goa.ErrNotFound(err.Error()))
}
return application.Transactional(c.db, func(appl application.Application) error {
_, err = appl.Spaces().Load(ctx, spaceID)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, goa.ErrNotFound(err.Error()))
}
iterations, err := appl.Iterations().List(ctx, spaceID)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
// fetch extra information(counts of WI in each iteration of the space) to be added in response
wiCounts, err := appl.WorkItems().GetCountsPerIteration(ctx, spaceID)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
res := &app.IterationList{}
res.Data = ConvertIterations(ctx.RequestData, iterations, UpdateIterationsWithCounts(wiCounts))
return ctx.OK(res)
})
}
// Load returns the work item link type for the given ID.
// Returns NotFoundError, ConversionError or InternalError
func (r *GormWorkItemLinkTypeRepository) Load(ctx context.Context, ID string) (*app.WorkItemLinkTypeSingle, error) {
id, err := satoriuuid.FromString(ID)
if err != nil {
// treat as not found: clients don't know it must be a UUID
return nil, errors.NewNotFoundError("work item link type", ID)
}
log.Info(ctx, map[string]interface{}{
"pkg": "link",
"wiltID": ID,
}, "Loading work item link type")
res := WorkItemLinkType{}
db := r.db.Model(&res).Where("id=?", ID).First(&res)
if db.RecordNotFound() {
log.Error(ctx, map[string]interface{}{
"wiltID": ID,
}, "work item link type not found")
return nil, errors.NewNotFoundError("work item link type", id.String())
}
if db.Error != nil {
return nil, errors.NewInternalError(db.Error.Error())
}
// Convert the created link type entry into a JSONAPI response
result := ConvertLinkTypeFromModel(res)
return &result, nil
}
func (mgm tokenManager) Extract(tokenString string) (*account.Identity, error) {
token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
return mgm.publicKey, nil
})
if err != nil {
return nil, errors.WithStack(err)
}
if !token.Valid {
return nil, errors.New("Token not valid")
}
claimedUUID := token.Claims.(jwt.MapClaims)["sub"]
if claimedUUID == nil {
return nil, errors.New("Subject can not be nil")
}
// in case of nil UUID, below type casting will fail hence we need above check
id, err := uuid.FromString(token.Claims.(jwt.MapClaims)["sub"].(string))
if err != nil {
return nil, errors.WithStack(err)
}
ident := account.Identity{
ID: id,
Username: token.Claims.(jwt.MapClaims)["preferred_username"].(string),
}
return &ident, nil
}
// Delete deletes the work item link with the given id
// returns NotFoundError or InternalError
func (r *GormWorkItemLinkRepository) Delete(ctx context.Context, ID string) error {
id, err := satoriuuid.FromString(ID)
if err != nil {
// treat as not found: clients don't know it must be a UUID
return errors.NewNotFoundError("work item link", ID)
}
var link = WorkItemLink{
ID: id,
}
log.Info(ctx, map[string]interface{}{
"pkg": "link",
"wilID": ID,
}, "Deleting the work item link repository")
db := r.db.Delete(&link)
if db.Error != nil {
log.Error(ctx, map[string]interface{}{
"wilID": ID,
"err": db.Error,
}, "unable to delete work item link repository")
return errors.NewInternalError(db.Error.Error())
}
if db.RowsAffected == 0 {
return errors.NewNotFoundError("work item link", id.String())
}
return nil
}
func (s *ApiServer) ForwardFetchFeed(ctx context.Context, req *pb.FeedRequest) (*pb.Feed, error) {
if req.PageSize <= 0 || req.PageSize >= 100 {
req.PageSize = 50
}
profile, err := store.GetProfile(s.mdb, req.Id)
if err != nil {
return nil, err
}
uuid1, _ := uuid.FromString(profile.Uuid)
preKey := store.NewUUIDKey(store.TableReverseEntryIndex, uuid1)
log.Println("forward seeking:", preKey.String())
start := req.Start
var entries []*pb.Entry
_, err = store.ForwardTableScan(s.rdb, preKey, func(i int, k, v []byte) error {
if start > 0 {
start--
return nil // continue
}
entry := new(pb.Entry)
rawdata, err := s.rdb.Get(v) // index value point to entry key
if err != nil || len(rawdata) == 0 {
return fmt.Errorf("entry data missing")
}
if err := proto.Unmarshal(rawdata, entry); err != nil {
return err
}
if err = FormatFeedEntry(s.mdb, req, entry); err != nil {
return err
}
entries = append(entries, entry)
if i > int(req.PageSize+req.Start) {
return &store.Error{"ok", store.StopIteration}
}
return nil
})
if err != nil {
return nil, err
}
feed := &pb.Feed{
Uuid: profile.Uuid,
Id: profile.Id,
Name: profile.Name,
Picture: profile.Picture,
Type: profile.Type,
Private: profile.Private,
SupId: profile.SupId,
Description: profile.Description,
Entries: entries[:],
}
return feed, nil
}
func TestNewWithAlphabet(t *testing.T) {
abc := DefaultAlphabet[:len(DefaultAlphabet)-1] + "="
enc := base57{newAlphabet(abc)}
u1, _ := uuid.FromString("e9ae9ba7-4fb1-4a6d-bbca-5315ed438371")
u2 := enc.Encode(u1)
if u2 != "u=BFWRLr5dXbeWf==iasZi" {
t.Errorf("expected uuid to be %q, got %q", "u=BFWRLr5dXbeWf==iasZi", u2)
}
}
func convertToUuid(uuidStrings []string) []uuid.UUID {
var uUIDs []uuid.UUID
for i := 0; i < len(uuidStrings); i++ {
uuidString, _ := uuid.FromString(uuidStrings[i])
uUIDs = append(uUIDs, uuidString)
}
return uUIDs
}
func deleteRecordWithUserId(input interface{}, id, userId string, session *xorm.Session) (statusCode int, err error) {
if _, err := uuid.FromString(id); err != nil {
return http.StatusBadRequest, errUuidNotValid
}
if _, err := uuid.FromString(userId); err != nil {
return http.StatusBadRequest, errUuidNotValid
}
affectedCount, err := session.Where("id = ? and user_id = ?", id, userId).Delete(input)
if err != nil {
return http.StatusInternalServerError, err
}
if affectedCount == 0 {
return http.StatusNotFound, errors.New("The record is not found.")
}
return http.StatusNoContent, err
}
// /a/comment
func (s *Server) CommentHandler(c *gin.Context) {
c.Request.ParseForm()
id := c.Request.Form.Get("id")
entryId := c.Request.Form.Get("entry")
rawBody := c.Request.Form.Get("body")
if entryId == "" || rawBody == "" {
c.JSON(http.StatusBadRequest, gin.H{"status": "bad request"})
return
}
body := util.DefaultSanitize(rawBody)
body = util.EntityToLink(body)
profile, _ := s.CurrentUser(c)
from := &pb.Feed{
Id: profile.Id,
Name: profile.Name,
Type: profile.Type,
}
comment := &pb.Comment{
Body: body,
RawBody: rawBody,
From: from,
}
var err error
var uuid1 uuid.UUID
if id != "" {
uuid1, err = uuid.FromString(id)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"status": "bad request"})
return
}
} else {
comment.Date = time.Now().UTC().Format(time.RFC3339)
name := entryId + profile.Uuid + comment.Date
uuid1 = uuid.NewV5(uuid.NamespaceURL, name)
}
comment.Id = uuid1.String()
req := &pb.CommentRequest{
Entry: entryId,
Comment: comment,
}
ctx, cancel := DefaultTimeoutContext()
defer cancel()
_, err = s.client.CommentEntry(ctx, req)
if RequestError(c, err) {
return
}
comment.Commands = []string{"edit", "delete"}
c.JSON(200, comment)
}
// handshakeStruct
func unpackHandshake(session int64, data []interface{}) (msg messageInterface, err error) {
u := uuid.UUID{}
if uuid_t, ok := data[0].([]byte); ok {
u, err = uuid.FromString(string(uuid_t))
if err != nil {
return
}
}
msg = &handshakeStruct{messageInfo{HANDSHAKE, session}, u}
return
}
func TestEncoding(t *testing.T) {
for _, test := range testVector {
u, err := uuid.FromString(test.uuid)
if err != nil {
t.Error(err)
}
suuid := New().Encode(u)
if suuid != test.shortuuid {
t.Errorf("expected %q, got %q", test.shortuuid, suuid)
}
}
}
func TestEvent(t *testing.T) {
var e Event
var eJSON = []byte(`
{
"id": "5b2e1b6f-b3f7-4a94-8b05-aa441606d886",
"event_type": "test_event_type",
"context": "test_context",
"original_account_id": "e4f05126-a0e8-437d-94f9-b553c959cdfb",
"payload": "Инстинкт плюс возможность, равно прибыль.",
"timestamp": "2015-07-10T10:50:34.437512Z"
}`)
if err := json.Unmarshal(eJSON, &e); err != nil {
t.Error(err.Error())
}
eAccountID, _ := uuid.FromString("e4f05126-a0e8-437d-94f9-b553c959cdfb")
eID, _ := uuid.FromString("5b2e1b6f-b3f7-4a94-8b05-aa441606d886")
eTime, _ := time.Parse(time.RFC3339, "2015-07-10T10:50:34.437512Z")
cases := []struct {
label, actual, expected interface{}
}{
{"id", e.ID, eID},
{"event type", e.EventType, "test_event_type"},
{"context", e.Context, "test_context"},
{"original account id", e.OriginalAccountID, eAccountID},
{"created at date", e.CreatedAt, eTime},
{"payload data", e.Data, "Инстинкт плюс возможность, равно прибыль."},
}
for _, c := range cases {
if c.actual != c.expected {
t.Errorf("Event %v is %q, but expected %q", c.label, c.actual, c.expected)
}
}
}
func strToEventIDSlice(str string) (UUIDs, error) {
result := make(UUIDs, 0, 10)
trimmed := strings.Trim(str, "{}")
for _, t := range strings.Split(trimmed, ",") {
id, err := uuid.FromString(t)
if err != nil {
return nil, err
}
result = append(result, id)
}
return result, nil
}
func getRecordWithUserIdDirect(out interface{}, id, userId string, db *xorm.Engine) (statusCode int, err error) {
if _, err := uuid.FromString(id); err != nil {
return http.StatusBadRequest, errUuidNotValid
}
found, err := db.Where("id = ? and user_id = ?", id, userId).Get(out)
if err != nil {
return http.StatusInternalServerError, err
}
if found == false {
return http.StatusNotFound, errNotFound
}
return http.StatusOK, nil
}
func (mgm tokenManager) Locate(ctx context.Context) (uuid.UUID, error) {
token := goajwt.ContextJWT(ctx)
if token == nil {
return uuid.UUID{}, errors.New("Missing token") // TODO, make specific tokenErrors
}
id := token.Claims.(jwt.MapClaims)["sub"]
if id == nil {
return uuid.UUID{}, errors.New("Missing sub")
}
idTyped, err := uuid.FromString(id.(string))
if err != nil {
return uuid.UUID{}, errors.New("uuid not of type string")
}
return idTyped, nil
}
// Update runs the update action.
func (c *IterationController) Update(ctx *app.UpdateIterationContext) error {
_, err := login.ContextIdentity(ctx)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, goa.ErrUnauthorized(err.Error()))
}
id, err := uuid.FromString(ctx.IterationID)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, goa.ErrNotFound(err.Error()))
}
return application.Transactional(c.db, func(appl application.Application) error {
itr, err := appl.Iterations().Load(ctx.Context, id)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
if ctx.Payload.Data.Attributes.Name != nil {
itr.Name = *ctx.Payload.Data.Attributes.Name
}
if ctx.Payload.Data.Attributes.StartAt != nil {
itr.StartAt = ctx.Payload.Data.Attributes.StartAt
}
if ctx.Payload.Data.Attributes.EndAt != nil {
itr.EndAt = ctx.Payload.Data.Attributes.EndAt
}
if ctx.Payload.Data.Attributes.Description != nil {
itr.Description = ctx.Payload.Data.Attributes.Description
}
if ctx.Payload.Data.Attributes.State != nil {
if *ctx.Payload.Data.Attributes.State == iteration.IterationStateStart {
res, err := appl.Iterations().CanStartIteration(ctx, itr)
if res == false && err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
}
itr.State = *ctx.Payload.Data.Attributes.State
}
itr, err = appl.Iterations().Save(ctx.Context, *itr)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
response := app.IterationSingle{
Data: ConvertIteration(ctx.RequestData, itr),
}
return ctx.OK(&response)
})
}
//the id should be a uuid
func getRecord(out interface{}, id string, session *xorm.Session) (statusCode int, err error) {
if _, err := uuid.FromString(id); err != nil {
return http.StatusBadRequest, errUuidNotValid
}
found, err := session.Id(id).Get(out)
if err != nil {
return http.StatusInternalServerError, err
}
if found == false {
return http.StatusNotFound, errNotFound
}
return http.StatusOK, nil
}
func checkClaims(claims *keycloakTokenClaims) error {
if claims.Subject == "" {
return errors.New("subject claim not found in token")
}
_, err := uuid.FromString(claims.Subject)
if err != nil {
return errors.New("subject claim from token is not UUID " + err.Error())
}
if claims.Username == "" {
return errors.New("username claim not found in token")
}
if claims.Email == "" {
return errors.New("email claim not found in token")
}
return nil
}
// Show runs the show action.
func (c *AreaController) Show(ctx *app.ShowAreaContext) error {
id, err := uuid.FromString(ctx.ID)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, goa.ErrNotFound(err.Error()))
}
return application.Transactional(c.db, func(appl application.Application) error {
a, err := appl.Areas().Load(ctx, id)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
res := &app.AreaSingle{}
res.Data = ConvertArea(appl, ctx.RequestData, a, addResolvedPath)
return ctx.OK(res)
})
}
