Example #1
1
func (test *TestIterationRepository) TestListIterationBySpace() {
	t := test.T()
	resource.Require(t, resource.Database)

	repo := iteration.NewIterationRepository(test.DB)

	spaceID := uuid.NewV4()

	for i := 0; i < 3; i++ {
		start := time.Now()
		end := start.Add(time.Hour * (24 * 8 * 3))
		name := "Sprint #2" + strconv.Itoa(i)

		i := iteration.Iteration{
			Name:    name,
			SpaceID: spaceID,
			StartAt: &start,
			EndAt:   &end,
		}
		repo.Create(context.Background(), &i)
	}
	repo.Create(context.Background(), &iteration.Iteration{
		Name:    "Other Spring #2",
		SpaceID: uuid.NewV4(),
	})

	its, err := repo.List(context.Background(), spaceID)
	assert.Nil(t, err)
	assert.Len(t, its, 3)
}
Example #2
0
func (test *TestAreaRepository) TestCreateChildArea() {
	t := test.T()

	resource.Require(t, resource.Database)

	repo := area.NewAreaRepository(test.DB)

	name := "Area #24"
	name2 := "Area #24.1"

	i := area.Area{
		Name:    name,
		SpaceID: uuid.NewV4(),
	}
	err := repo.Create(context.Background(), &i)
	assert.Nil(t, err)

	// ltree field doesnt accept "-" , so we will save them as "_"
	expectedPath := strings.Replace((i.ID).String(), "-", "_", -1)
	area2 := area.Area{
		Name:    name2,
		SpaceID: uuid.NewV4(),
		Path:    expectedPath,
	}
	err = repo.Create(context.Background(), &area2)
	assert.Nil(t, err)

	actualArea, err := repo.Load(context.Background(), area2.ID)
	actualPath := actualArea.Path
	require.Nil(t, err)
	require.NotNil(t, actualArea)
	assert.Equal(t, expectedPath, actualPath)

}
Example #3
0
func (test *TestCommentRepository) TestDeleteComment() {
	t := test.T()
	resource.Require(t, resource.Database)

	defer cleaner.DeleteCreatedEntities(test.DB)()

	repo := comment.NewCommentRepository(test.DB)

	parentID := "AA"
	c := &comment.Comment{
		ParentID:  parentID,
		Body:      "Test AA",
		CreatedBy: uuid.NewV4(),
		ID:        uuid.NewV4(),
	}

	repo.Create(context.Background(), c)
	if c.ID == uuid.Nil {
		t.Errorf("Comment was not created, ID nil")
	}

	c.Body = "Test AB"
	err := repo.Delete(context.Background(), c.ID)

	if err != nil {
		t.Error("Failed to Delete", err.Error())
	}

}
Example #4
0
func (test *TestIterationRepository) TestCreateChildIteration() {
	t := test.T()
	resource.Require(t, resource.Database)

	repo := iteration.NewIterationRepository(test.DB)

	start := time.Now()
	end := start.Add(time.Hour * (24 * 8 * 3))
	name := "Sprint #24"
	name2 := "Sprint #24.1"

	i := iteration.Iteration{
		Name:    name,
		SpaceID: uuid.NewV4(),
		StartAt: &start,
		EndAt:   &end,
	}
	repo.Create(context.Background(), &i)

	i2 := iteration.Iteration{
		Name:     name2,
		SpaceID:  uuid.NewV4(),
		StartAt:  &start,
		EndAt:    &end,
		ParentID: i.ID,
	}
	repo.Create(context.Background(), &i2)

	i2L, err := repo.Load(context.Background(), i2.ID)
	require.Nil(t, err)
	assert.NotEqual(t, uuid.Nil, i2.ParentID)
	assert.Equal(t, i2.ParentID, i2L.ParentID)
}
Example #5
0
func (test *TestAreaRepository) TestListImmediateChildrenOfGrandParents() {
	t := test.T()

	resource.Require(t, resource.Database)
	repo := area.NewAreaRepository(test.DB)

	name := "Area #240"
	name2 := "Area #240.1"
	name3 := "Area #240.1.3"

	// *** Create Parent Area ***

	i := area.Area{
		Name:    name,
		SpaceID: uuid.NewV4(),
	}
	err := repo.Create(context.Background(), &i)
	assert.Nil(t, err)

	// *** Create 'son' area ***

	expectedPath := strings.Replace((i.ID).String(), "-", "_", -1)
	area2 := area.Area{
		Name:    name2,
		SpaceID: uuid.NewV4(),
		Path:    expectedPath,
	}
	err = repo.Create(context.Background(), &area2)
	require.Nil(t, err)

	childAreaList, err := repo.ListChildren(context.Background(), &i)
	assert.Equal(t, 1, len(childAreaList))
	require.Nil(t, err)

	// *** Create 'grandson' area ***

	expectedPath = strings.Replace((i.ID).String()+"."+(area2.ID.String()), "-", "_", -1)
	area4 := area.Area{
		Name:    name3,
		SpaceID: uuid.NewV4(),
		Path:    expectedPath,
	}
	err = repo.Create(context.Background(), &area4)
	require.Nil(t, err)

	childAreaList, err = repo.ListChildren(context.Background(), &i)

	// But , There is only 1 'son' .

	require.Nil(t, err)
	assert.Equal(t, 1, len(childAreaList))
	assert.Equal(t, area2.ID, childAreaList[0].ID)

	// *** Confirm the grandson has no son

	childAreaList, err = repo.ListChildren(context.Background(), &area4)
	assert.Equal(t, 0, len(childAreaList))
}
Example #6
0
func (rest *TestSpaceAreaREST) TestListAreas() {
	t := rest.T()
	resource.Require(t, resource.Database)

	// Create a new space where we'll create 3 areas
	var s *space.Space

	// Create another space where we'll create 1 area.
	var anotherSpace *space.Space

	application.Transactional(rest.db, func(app application.Application) error {
		var err error
		repo := app.Spaces()
		newSpace := &space.Space{
			Name: "Test Space 1" + uuid.NewV4().String(),
		}
		s, err = repo.Create(context.Background(), newSpace)
		require.Nil(t, err)

		newSpace = &space.Space{
			Name: "Another space" + uuid.NewV4().String(),
		}
		anotherSpace, err = repo.Create(context.Background(), newSpace)
		require.Nil(t, err)
		return nil
	})

	svc, ctrl := rest.SecuredController()
	spaceId := s.ID
	anotherSpaceId := anotherSpace.ID
	var createdAreaUuids1 []uuid.UUID

	for i := 0; i < 3; i++ {
		name := "Test Area #20" + strconv.Itoa(i)
		spaceAreaContext := createSpaceArea(name, &name)
		_, c := test.CreateSpaceAreasCreated(t, svc.Context, svc, ctrl, spaceId.String(), spaceAreaContext)
		require.NotNil(t, c.Data.ID)
		require.NotNil(t, c.Data.Relationships.Space)
		createdAreaUuids1 = append(createdAreaUuids1, *c.Data.ID)
	}

	name := "area in a different space"
	anotherSpaceAreaContext := createSpaceArea(name, &name)
	_, createdArea := test.CreateSpaceAreasCreated(t, svc.Context, svc, ctrl, anotherSpaceId.String(), anotherSpaceAreaContext)
	require.NotNil(t, createdArea)

	_, areaList := test.ListSpaceAreasOK(t, svc.Context, svc, ctrl, spaceId.String())
	assert.Len(t, areaList.Data, 3)
	for i := 0; i < len(createdAreaUuids1); i++ {
		assert.NotNil(t, searchInAreaSlice(createdAreaUuids1[i], areaList))
	}

	_, anotherAreaList := test.ListSpaceAreasOK(t, svc.Context, svc, ctrl, anotherSpaceId.String())
	assert.Len(t, anotherAreaList.Data, 1)
	assert.Equal(t, anotherAreaList.Data[0].ID, createdArea.Data.ID)

}
func TestListIdentities(t *testing.T) {
	resource.Require(t, resource.Database)
	defer cleaner.DeleteCreatedEntities(DB)()

	service := goa.New("Test-Identities")
	app := gormapplication.NewGormDB(DB)
	identityController := NewIdentityController(service, app)
	_, ic := test.ListIdentityOK(t, service.Context, service, identityController)
	require.NotNil(t, ic)

	numberOfCurrentIdent := len(ic.Data)

	ctx := context.Background()

	identityRepo := app.Identities()

	identity := account.Identity{
		Username: "******",
		Provider: "test-idp",
		ID:       uuid.NewV4(),
	}

	err := identityRepo.Create(ctx, &identity)
	if err != nil {
		t.Fatal(err)
	}

	_, ic2 := test.ListIdentityOK(t, service.Context, service, identityController)
	require.NotNil(t, ic2)

	assert.Equal(t, numberOfCurrentIdent+1, len(ic2.Data))

	assertIdent(t, identity, findIdent(identity.ID, ic2.Data))

	identity2 := account.Identity{
		Username: "******",
		Provider: "test-idp",
		ID:       uuid.NewV4(),
	}

	err = identityRepo.Create(ctx, &identity2)
	if err != nil {
		t.Fatal(err)
	}

	_, ic3 := test.ListIdentityOK(t, service.Context, service, identityController)
	require.NotNil(t, ic3)
	assert.Equal(t, numberOfCurrentIdent+2, len(ic3.Data))

	assertIdent(t, identity, findIdent(identity.ID, ic3.Data))
	assertIdent(t, identity2, findIdent(identity2.ID, ic3.Data))
}
Example #8
0
func createAndRegisterUser(
	passwordHasher security.PasswordHasher,
	repository lib.UserRepository,
	request *request.RegistrationRequest,
) (*model.User, error) {
	confirmationToken := uuid.NewV4().String()
	hashedPassword, err := passwordHasher.Hash(request.Password)
	if err != nil {
		return nil, err
	}

	user := model.NewUser(
		request.Email,
		hashedPassword,
		request.FirstName,
		request.LastName,
		confirmationToken,
	)

	err = repository.Insert(user)
	if err != nil {
		return nil, err
	}

	return user, nil
}
Example #9
0
func BenchmarkEncoding(b *testing.B) {
	u := uuid.NewV4()
	su := New()
	for i := 0; i < b.N; i++ {
		su.Encode(u)
	}
}
Example #10
0
// Handler makes it possible to use a RouteHandler where a http.Handler is required
func Handler(e *Endpoint) http.Handler {
	HTTPHandler := func(resWriter http.ResponseWriter, req *http.Request) {
		request := &Request{
			ID:       uuid.NewV4().String()[:8],
			Request:  req,
			Response: resWriter,
		}

		request.Response.Header().Set("X-Request-Id", request.ID)

		if e.Params != nil {
			// We give request.Params the same type as e.Params
			request.Params = reflect.New(reflect.TypeOf(e.Params).Elem()).Interface()
			if err := request.ParseParams(); err != nil {
				request.Error(err)
				return
			}
		}

		defer request.handlePanic()

		accessGranted := e.Auth == nil || e.Auth(request)
		if accessGranted {
			e.Handler(request)
		}
	}

	return http.HandlerFunc(HTTPHandler)
}
Example #11
0
func DuplicateSlide(pptRootPath, slideName string) (newSlideName string, err error) {
	newSlideName = uuid.NewV4().String() + ".xml"
	newSlideName = "slilde2.xml"

	slidePath := filepath.Join(pptRootPath, c.PPTFolder, c.SlideFolder, slideName)
	newSlidePath := filepath.Join(pptRootPath, c.PPTFolder, c.SlideFolder, newSlideName)

	err = fo.CopyFile(slidePath, newSlidePath)
	if err != nil {
		return "", err
	}

	sourceSlideRelsPath := filepath.Join(pptRootPath, c.PPTFolder, c.SlideFolder, c.RelsFolder, slideName+relsExtension)
	newSlideRelsPath := filepath.Join(pptRootPath, c.PPTFolder, c.SlideFolder, c.RelsFolder, newSlideName+relsExtension)

	err = fo.CopyFile(sourceSlideRelsPath, newSlideRelsPath)
	if err != nil {
		return "", err
	}

	rid, err := createRelations(pptRootPath, newSlideName)
	if err != nil {
		return "", err
	}

	err = addSlideInPresentation(pptRootPath, rid)
	if err != nil {
		return "", err
	}

	return newSlideName, addSlideContentTypeInContentTypes(pptRootPath, newSlideName)
}
Example #12
0
File: main.go Project: niukey/learn
func wrapRouterWithLogrus(h http.Handler) http.HandlerFunc {
	return func(w http.ResponseWriter, req *http.Request) {
		defer func() {
			if err := recover(); err != nil {
				log.Printf("recovered from panic: %+v / %+v", err, req)
				// http.Error(w, http.StatusText(500), 500)
			}
		}()
		start := time.Now()
		h.ServeHTTP(w, req)
		took := time.Since(start)
		ip, err := getIP(req)
		if err != nil {
			log.Warnf("getIP error: %v", err)
		}
		log.WithFields(log.Fields{
			"event_type": "router",
			"referrer":   req.Referer(),
			"ua":         req.UserAgent(),
			"method":     req.Method,
			"path":       req.URL.Path,
			"ip":         ip,
			"uuid":       uuid.NewV4(),
		}).Debugf("took %s", took)
	}
}
Example #13
0
func (test *TestIterationRepository) TestCreateIteration() {
	t := test.T()
	resource.Require(t, resource.Database)

	repo := iteration.NewIterationRepository(test.DB)

	start := time.Now()
	end := start.Add(time.Hour * (24 * 8 * 3))
	name := "Sprint #24"

	i := iteration.Iteration{
		Name:    name,
		SpaceID: uuid.NewV4(),
		StartAt: &start,
		EndAt:   &end,
	}

	repo.Create(context.Background(), &i)
	if i.ID == uuid.Nil {
		t.Errorf("Iteration was not created, ID nil")
	}

	if i.CreatedAt.After(time.Now()) {
		t.Errorf("Iteration was not created, CreatedAt after Now()?")
	}
	assert.Equal(t, start, *i.StartAt)
	assert.Equal(t, end, *i.EndAt)
	assert.Equal(t, name, i.Name)
}
Example #14
0
func WithLogrus(h http.Handler) http.HandlerFunc {
	return func(w http.ResponseWriter, req *http.Request) {

		defer func() {
			if err := recover(); err != nil {
				log.WithFields(log.Fields{
					"event_type": "panic_recover",
					"referrer":   req.Referer(),
					"ua":         req.UserAgent(),
					"method":     req.Method,
					"path":       req.URL.Path,
					"ip":         req.RemoteAddr,
					"real_ip":    getRealIP(req),
					"error":      err,
				}).Errorln("WithLogrus error")
			}
		}()

		start := nowPacific()
		h.ServeHTTP(w, req)
		took := time.Since(start)

		log.WithFields(log.Fields{
			"event_type": "web_server",
			"referrer":   req.Referer(),
			"ua":         req.UserAgent(),
			"method":     req.Method,
			"path":       req.URL.Path,
			"ip":         req.RemoteAddr,
			"real_ip":    getRealIP(req),
			"uuid":       uuid.NewV4(),
		}).Debugf("took %s", took)
	}
}
Example #15
0
File: issue.go Project: yweber/gogs
// NewAttachment creates a new attachment object.
func NewAttachment(name string, buf []byte, file multipart.File) (_ *Attachment, err error) {
	attach := &Attachment{
		UUID: gouuid.NewV4().String(),
		Name: name,
	}

	if err = os.MkdirAll(path.Dir(attach.LocalPath()), os.ModePerm); err != nil {
		return nil, fmt.Errorf("MkdirAll: %v", err)
	}

	fw, err := os.Create(attach.LocalPath())
	if err != nil {
		return nil, fmt.Errorf("Create: %v", err)
	}
	defer fw.Close()

	if _, err = fw.Write(buf); err != nil {
		return nil, fmt.Errorf("Write: %v", err)
	} else if _, err = io.Copy(fw, file); err != nil {
		return nil, fmt.Errorf("Copy: %v", err)
	}

	sess := x.NewSession()
	defer sessionRelease(sess)
	if err := sess.Begin(); err != nil {
		return nil, err
	}

	if _, err := sess.Insert(attach); err != nil {
		return nil, err
	}

	return attach, sess.Commit()
}
Example #16
0
func (k *Kloud) AuthPasswordLogin(r *kite.Request) (interface{}, error) {
	var req PasswordLoginRequest

	if err := getReq(r, &req); err != nil {
		return nil, err
	}

	if _, err := modelhelper.CheckAndGetUser(req.Username, req.Password); err != nil {
		return nil, errors.New("username and/or password does not match")
	}

	resp, err := k.authLogin(req.Username, &req.LoginRequest)
	if err != nil {
		return nil, err
	}

	kiteKey, err := k.Userdata.Keycreator.Create(req.Username, uuid.NewV4().String())
	if err != nil {
		return nil, err
	}

	return &PasswordLoginResponse{
		LoginResponse: *resp,
		KiteKey:       kiteKey,
	}, nil
}
Example #17
0
func (test *TestAreaRepository) TestCreateArea() {
	t := test.T()

	resource.Require(t, resource.Database)

	repo := area.NewAreaRepository(test.DB)

	name := "Area 21"

	i := area.Area{
		Name:    name,
		SpaceID: uuid.NewV4(),
	}

	repo.Create(context.Background(), &i)
	if i.ID == uuid.Nil {
		t.Errorf("Area was not created, ID nil")
	}

	if i.CreatedAt.After(time.Now()) {
		t.Errorf("Area was not created, CreatedAt after Now()?")
	}

	assert.Equal(t, name, i.Name)
}
Example #18
0
// Create runs the create action.
func (c *UserspaceController) Create(ctx *app.CreateUserspaceContext) error {
	return models.Transactional(c.db, func(db *gorm.DB) error {

		path := ctx.RequestURI

		data := Data{}
		err := c.db.Where("path = ?", path).First(&data).Error
		fmt.Println(err)
		if err != nil {
			data = Data{
				ID:   uuid.NewV4(),
				Path: ctx.RequestURI,
				Data: workitem.Fields(ctx.Payload),
			}
			err := c.db.Create(&data).Error
			if err != nil {
				goa.LogError(ctx, "error adding data", "error", err.Error())
				return ctx.InternalServerError()
			}
		} else {
			err := c.db.Model(&data).Update("data", workitem.Fields(ctx.Payload)).Error
			if err != nil {
				goa.LogError(ctx, "error updating data", "error", err.Error())
				return ctx.InternalServerError()
			}
		}
		return ctx.NoContent()
	})
}
Example #19
0
func (v *vm) Create(attr vms.MachineAttributes) (vms.Machine, error) {
	if waitNextCall {
		time.Sleep(time.Duration(waitDelay) * time.Millisecond)
		waitNextCall = false
		waitDelay = 0
	}
	if failNextCall {
		failNextCall = false
		return nil, failError
	}
	if nilNextCall {
		nilNextCall = false
		return nil, nil
	}
	if attr.Type == nil {
		attr.Type = &defaultMachineType
	}

	t, ok := attr.Type.(*machineType)
	if !ok {
		return nil, errors.New("VM Type not supported")
	}

	new_machine := machine{
		id:          uuid.NewV4().String(),
		name:        attr.Name,
		machineType: *t,
		status:      vms.StatusUp,
	}
	allMachines = append(allMachines, &new_machine)

	return &new_machine, nil
}
Example #20
0
// StartRecovery ...
func (pr *passwordRecoverer) Start(email string) error {
	user, err := pr.userRepository.FindOneByUsername(email)
	if err != nil {
		return err
	}

	if !user.IsActive {
		return ErrPasswordRecovererUserIsNotActive
	}

	if !user.IsConfirmed {
		return ErrPasswordRecovererUserIsNotConfirmed
	}

	passwordRecovery, err := pr.passwordRecoveryRepository.Create(user.ID, uuid.NewV4().String())
	if err != nil {
		return err
	}

	err = pr.mailer.Send(user.Username, map[string]interface{}{
		"user_id":            passwordRecovery.UserID,
		"confirmation_token": passwordRecovery.ConfirmationToken,
	})
	if err != nil {
		return err
	}

	return nil
}
Example #21
0
func wrapHandlerFunc2(fn func(w http.ResponseWriter, req *http.Request)) func(w http.ResponseWriter, req *http.Request) {
	return func(w http.ResponseWriter, req *http.Request) {
		defer func() {
			if err := recover(); err != nil {
				log.Printf("recovered from panic: %+v / %+v", err, req)
				// http.Error(w, http.StatusText(500), 500)
			}
		}()

		start := time.Now()
		fn(w, req) // execute the handler
		took := time.Since(start)

		// ip, err := getIP(req)
		// if err != nil {
		// 	log.Warnf("getIP error: %v", err)
		// }

		log.WithFields(log.Fields{
			"event_type": runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name(),
			"referrer":   req.Referer(),
			"ua":         req.UserAgent(),
			"method":     req.Method,
			"path":       req.URL.Path,
			"ip":         req.RemoteAddr,
			"real_ip":    getRealIP(req),
			"uuid":       uuid.NewV4(),
		}).Debugf("took %s", took)
	}
}
Example #22
0
func (self *Connection) FragmentMessage(contents []byte) []domain.UserMessage {
	messageBase := domain.MessageBase{
		SendRouteID: self.Route.ForwardToRouteID,
		SendBack:    false,
		FromPeerID:  self.Node.Config.PubKey,
		Nonce:       mesh.GenerateNonce(),
	}

	fragmentsBuf := make([]domain.UserMessage, 0)
	maxContentLength := self.GetMaximumContentLength()
	fmt.Fprintf(os.Stdout, "MaxContentLength: %v\n", maxContentLength)
	remainingBytes := contents[:]
	messageID := (domain.MessageID)(uuid.NewV4())
	for len(remainingBytes) > 0 {
		nBytesThisMessage := min(maxContentLength, (uint64)(len(remainingBytes)))
		bytesThisMessage := remainingBytes[:nBytesThisMessage]
		remainingBytes = remainingBytes[nBytesThisMessage:]
		message := domain.UserMessage{
			MessageBase: messageBase,
			MessageID:   messageID,
			Index:       (uint64)(len(fragmentsBuf)),
			Count:       0,
			Contents:    bytesThisMessage,
		}
		fragmentsBuf = append(fragmentsBuf, message)
	}
	fragments := make([]domain.UserMessage, 0)
	for _, message := range fragmentsBuf {
		message.Count = (uint64)(len(fragmentsBuf))
		fragments = append(fragments, message)
	}
	fmt.Fprintf(os.Stdout, "Message fragmented in %v packets.\n", len(fragments))
	return fragments
}
func (rest *TestSpaceIterationREST) TestFailListIterationsByMissingSpace() {
	t := rest.T()
	resource.Require(t, resource.Database)

	svc, ctrl := rest.UnSecuredController()
	test.ListSpaceIterationsNotFound(t, svc.Context, svc, ctrl, uuid.NewV4().String())
}
Example #24
0
// NewAttachment creates a new attachment object.
func NewAttachment(name string, buf []byte, file multipart.File) (_ *Attachment, err error) {
	attach := &Attachment{
		UUID: gouuid.NewV4().String(),
		Name: name,
	}

	localPath := attach.LocalPath()
	if err = os.MkdirAll(path.Dir(localPath), os.ModePerm); err != nil {
		return nil, fmt.Errorf("MkdirAll: %v", err)
	}

	fw, err := os.Create(localPath)
	if err != nil {
		return nil, fmt.Errorf("Create: %v", err)
	}
	defer fw.Close()

	if _, err = fw.Write(buf); err != nil {
		return nil, fmt.Errorf("Write: %v", err)
	} else if _, err = io.Copy(fw, file); err != nil {
		return nil, fmt.Errorf("Copy: %v", err)
	}

	if _, err := x.Insert(attach); err != nil {
		return nil, err
	}

	return attach, nil
}
Example #25
0
File: user.go Project: blang/posty
// NewUser creates a new user. The object is not saved to the database.
func (p *DynamoUserPeer) NewUser() *model.User {
	return &model.User{
		Peer:      p,
		ID:        uuid.NewV4().String(),
		CreatedAt: time.Now(),
	}
}
Example #26
0
// AddKeyPair add the given key pair so it can be used to validate and
// sign/generate tokens. If id is empty, a unique ID will be generated. The
// last added key pair is also used to generate tokens for machine
// registrations via "handleMachine" method. This can be overiden with the
// kontorl.MachineKeyPicker function.
func (k *Kontrol) AddKeyPair(id, public, private string) error {
	if k.keyPair == nil {
		k.log.Warning("Key pair storage is not set. Using in memory cache")
		k.keyPair = NewMemKeyPairStorage()
	}

	if id == "" {
		i := uuid.NewV4()
		id = i.String()
	}

	public = strings.TrimSpace(public)
	private = strings.TrimSpace(private)

	keyPair := &KeyPair{
		ID:      id,
		Public:  public,
		Private: private,
	}

	// set last set key pair
	k.lastIDs = append(k.lastIDs, id)
	k.lastPublic = append(k.lastPublic, public)
	k.lastPrivate = append(k.lastPrivate, private)

	if err := keyPair.Validate(); err != nil {
		return err
	}

	return k.keyPair.AddKey(keyPair)
}
Example #27
0
File: scp.go Project: zqzca/back
func (s *scpRequest) DownloadFile(channel ssh.Channel, req *ssh.Request) error {
	uid := uuid.NewV4()
	s.filename = filepath.Join(os.TempDir(), uid.String())

	log.Println("saving to:", s.filename)
	f, err := os.OpenFile(s.filename, os.O_CREATE|os.O_WRONLY, 0664)
	if err != nil {
		return errors.Wrap(err, "failed to open file for downloading")
	}

	h := sha1.New()
	mw := io.MultiWriter(f, h)
	// Read file contents
	var n int64
	if n, err = io.CopyN(mw, channel, s.size); err != nil {
		return errors.Wrap(err, "failed to download file")
	}
	log.Println("copied", n, "bytes")

	if err = f.Close(); err != nil {
		return errors.Wrap(err, "failed to close file")
	}

	s.hash = fmt.Sprintf("%x", h.Sum(nil))

	fmt.Println("Sha'd file", s.hash)

	return nil
}
Example #28
0
func (rest *TestAreaREST) TestFailShowAreaNotFound() {
	t := rest.T()
	resource.Require(t, resource.Database)

	svc, ctrl := rest.SecuredController()
	test.ShowAreaNotFound(t, svc.Context, svc, ctrl, uuid.NewV4().String())
}
Example #29
0
func BenchmarkEtcdAdd(b *testing.B) {
	kon.SetStorage(NewEtcd(nil, kon.Kite.Log))

	newKite := func() *protocol.Kite {
		id := uuid.NewV4()
		return &protocol.Kite{
			Username:    "******",
			Environment: "bench-env",
			Name:        "mathworker",
			Version:     "1.1.1",
			Region:      "bench",
			Hostname:    "bench-host",
			ID:          id.String(),
		}
	}

	value := &kontrolprotocol.RegisterValue{
		URL: "http://localhost:4444/kite",
	}

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		kon.storage.Add(newKite(), value)
	}
}
Example #30
0
// NewUpload creates a new upload object.
func NewUpload(name string, buf []byte, file multipart.File) (_ *Upload, err error) {
	upload := &Upload{
		UUID: gouuid.NewV4().String(),
		Name: name,
	}

	localPath := upload.LocalPath()
	if err = os.MkdirAll(path.Dir(localPath), os.ModePerm); err != nil {
		return nil, fmt.Errorf("MkdirAll: %v", err)
	}

	fw, err := os.Create(localPath)
	if err != nil {
		return nil, fmt.Errorf("Create: %v", err)
	}
	defer fw.Close()

	if _, err = fw.Write(buf); err != nil {
		return nil, fmt.Errorf("Write: %v", err)
	} else if _, err = io.Copy(fw, file); err != nil {
		return nil, fmt.Errorf("Copy: %v", err)
	}

	if _, err := x.Insert(upload); err != nil {
		return nil, err
	}

	return upload, nil
}