ambee/giterated

// TODO: This is far from ideal or speedy and would love for a better way to check this in the same order, but I can't find proper methods to do any of this.

361

362

// Try getting it as a refname (refs/heads/name)

363

if let Ok(oid) = git.refname_to_id(rev) {

364

Ok(oid)

365

// Try finding it as a short branch name

366

} else if let Ok(branch) = git.find_branch(rev, BranchType::Local) {

367

// SHOULD be safe to unwrap

368

Ok(branch.get().target().unwrap())

369

// As last resort, try revparsing (will catch short oid and tags)

370

} else if let Ok(object) = git.revparse_single(rev) {

371

Ok(object.id())

372

} else {

373

Err(GitBackendError::RefNotFound(rev.to_string()))

}

}

/// Gets the last commit in a rev

378

pub fn get_last_commit_in_rev(git: &git2::Repository, rev: &str) -> anyhow::Result<Commit> {

379

let oid = Self::get_oid_from_reference(git, Some(rev))?;

380

381

// Walk through the repository commit graph starting at our rev

382

let mut revwalk = git.revwalk()?;

383

revwalk.set_sorting(git2::Sort::TIME)?;

384

revwalk.push(oid)?;

385

386

if let Some(Ok(commit_oid)) = revwalk.next() {

387

if let Ok(commit) = git

388

.find_commit(commit_oid)

389

.map_err(|_| GitBackendError::CommitNotFound(commit_oid.to_string()))

390

{

391

return Ok(Commit::from(commit));

}

}

Err(GitBackendError::RefNotFound(oid.to_string()).into())

}

}

#[async_trait]

impl RepositoryBackend for GitBackend {

401

async fn exists(

402

&mut self,

403

requester: &Option<AuthenticatedUser>,

404

repository: &Repository,

405

) -> Result<bool, Error> {

406

if let Ok(repository) = self

407

.find_by_owner_user_name(&repository.owner.clone(), &repository.name)

.await

{

Ok(repository

.can_user_view_repository(&self.instance, requester, self.stack.get().unwrap())

.await)

} else {

Ok(false)

}

}

async fn create_repository(

419

&mut self,

420

_user: &AuthenticatedUser,

421

request: &RepositoryCreateRequest,

422

) -> Result<Repository, GitBackendError> {

423

// Check if repository already exists in the database

424

if let Ok(repository) = self

425

.find_by_owner_user_name(&request.owner, &request.name)

426

.await

427

{

428

let err = GitBackendError::RepositoryAlreadyExists {

429

owner_user: repository.owner_user.to_string(),

};

error!("{:?}", err);

return Err(err);

}

// Insert the repository into the database

438

let _ = match sqlx::query_as!(GitRepository,

439

r#"INSERT INTO repositories VALUES ($1, $2, $3, $4, $5) RETURNING owner_user, name, description, visibility as "visibility: _", default_branch"#,

440

request.owner.to_string(), request.name, request.description, request.visibility as _, "master")

441

.fetch_one(&self.pg_pool.clone())

442

.await {

443

Ok(repository) => repository,

444

Err(err) => {

445

let err = GitBackendError::FailedInsertingIntoDatabase(err);

446

error!("Failed inserting into the database! {:?}", err);

return Err(err);

}

};

// Create bare (server side) repository on disk

453

match git2::Repository::init_bare(PathBuf::from(format!(

454

"{}/{}/{}/{}",

455

self.repository_folder, request.owner.instance, request.owner.username, request.name

))) {

Ok(_) => {

debug!(

"Created new repository with the name {}/{}/{}",

460

request.owner.instance, request.owner.username, request.name

461

);

462

463

let stack = self.stack.get().unwrap();

464

465

let repository = Repository {

466

owner: request.owner.clone(),

467

468

instance: request.instance.as_ref().unwrap_or(&self.instance).clone(),

};

stack

.write_setting(

&repository,

Description(request.description.clone().unwrap_or_default()),

)

.await

.unwrap();

stack

.write_setting(&repository, Visibility(request.visibility.clone()))

.await

.unwrap();

stack

.write_setting(&repository, DefaultBranch(request.default_branch.clone()))

.await

.unwrap();

Ok(repository)

}

Err(err) => {

let err = GitBackendError::FailedCreatingRepository(err);

493

error!("Failed creating repository on disk {:?}", err);

494

495

// Delete repository from database

496

self.delete_from_database(&request.owner, request.name.as_str())

.await?;

// ???

Err(err)

}

}

}

/// If the OID can't be found because there's no repository head, this will return an empty `Vec`.

506

async fn repository_file_inspect(

507

&mut self,

508

requester: &Option<AuthenticatedUser>,

509

repository: &Repository,

510

request: &RepositoryFileInspectRequest,

511

) -> Result<Vec<RepositoryTreeEntry>, Error> {

512

let git = self

513

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

514

.await?;

515

516

// Try and find the tree_id/branch

517

let tree_id = match Self::get_oid_from_reference(&git, request.rev.as_deref()) {

518

Ok(oid) => oid,

519

Err(GitBackendError::HeadNotFound) => return Ok(vec![]),

520

Err(err) => return Err(err.into()),

521

};

522

523

// Get the commit from the oid

524

let commit = match git.find_commit(tree_id) {

525

Ok(commit) => commit,

526

// If the commit isn't found, it's generally safe to assume the tree is empty.

527

Err(_) => return Ok(vec![]),

};

// this is stupid

let rev = request.rev.clone().unwrap_or_else(|| "master".to_string());

532

let mut current_path = rev.clone();

533

534

// Get the commit tree

535

let git_tree = if let Some(path) = &request.path {

536

// Add it to our full path string

537

current_path.push_str(format!("/{}", path).as_str());

538

// Get the specified path, return an error if it wasn't found.

539

let entry = match commit

540

.tree()

541

.unwrap()

542

.get_path(&PathBuf::from(path))

543

.map_err(|_| GitBackendError::PathNotFound(path.to_string()))

544

{

545

Ok(entry) => entry,

546

Err(err) => return Err(Box::new(err).into()),

547

};

548

// Turn the entry into a git tree

549

entry.to_object(&git).unwrap().as_tree().unwrap().clone()

550

} else {

551

commit.tree().unwrap()

552

};

553

554

// Iterate over the git tree and collect it into our own tree types

555

let mut tree = git_tree

556

.iter()

557

.map(|entry| {

558

let object_type = match entry.kind().unwrap() {

559

git2::ObjectType::Tree => RepositoryObjectType::Tree,

560

git2::ObjectType::Blob => RepositoryObjectType::Blob,

561

_ => unreachable!(),

562

};

563

let mut tree_entry = RepositoryTreeEntry::new(

564

entry.id().to_string().as_str(),

565

entry.name().unwrap(),

object_type,

entry.filemode(),

);

if request.extra_metadata {

571

// Get the file size if It's a blob

572

let object = entry.to_object(&git).unwrap();

573

if let Some(blob) = object.as_blob() {

574

tree_entry.size = Some(blob.size());

575

}

576

577

// Get the path to the folder the file is in by removing the rev from current_path

578

let mut path = current_path.replace(&rev, "");

579

if path.starts_with('/') {

path.remove(0);

}

// Format it as the path + file name

584

let full_path = if path.is_empty() {

585

entry.name().unwrap().to_string()

586

} else {

587

format!("{}/{}", path, entry.name().unwrap())

588

};

589

590

// Get the last commit made to the entry

591

if let Ok(last_commit) =

592

GitBackend::get_last_commit_of_file(&full_path, &git, &commit)

593

{

594

tree_entry.last_commit = Some(last_commit);

}

}

tree_entry

})

.collect::<Vec<RepositoryTreeEntry>>();

601

602

// Sort the tree alphabetically and with tree first

603

tree.sort_unstable_by_key(|entry| entry.name.to_lowercase());

604

tree.sort_unstable_by_key(|entry| {

605

std::cmp::Reverse(format!("{:?}", entry.object_type).to_lowercase())

});

Ok(tree)

}

async fn repository_file_from_id(

612

&mut self,

613

requester: &Option<AuthenticatedUser>,

614

repository: &Repository,

615

request: &RepositoryFileFromIdRequest,

616

) -> Result<RepositoryFile, Error> {

617

let git = self

618

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

619

.await?;

620

621

// Parse the passed object id

622

let oid = match git2::Oid::from_str(request.0.as_str()) {

623

Ok(oid) => oid,

624

Err(_) => {

625

return Err(Box::new(GitBackendError::InvalidObjectId(request.0.clone())).into())

}

};

// Find the file and turn it into our own struct

630

let file = match git.find_blob(oid) {

631

Ok(blob) => RepositoryFile {

632

id: blob.id().to_string(),

633

content: blob.content().to_vec(),

634

binary: blob.is_binary(),

635

size: blob.size(),

636

},

637

Err(_) => return Err(Box::new(GitBackendError::BlobNotFound(oid.to_string())).into()),

};

Ok(file)

}

async fn repository_file_from_path(

644

&mut self,

645

requester: &Option<AuthenticatedUser>,

646

repository: &Repository,

647

request: &RepositoryFileFromPathRequest,

648

) -> Result<(RepositoryFile, String), Error> {

649

let git = self

650

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

651

.await?;

652

653

let tree_id = Self::get_oid_from_reference(&git, request.rev.as_deref())?;

654

655

// unwrap might be dangerous?

656

// Get the commit from the oid

657

let commit = git.find_commit(tree_id).unwrap();

658

659

// this is stupid

660

let mut current_path = request.rev.clone().unwrap_or_else(|| "master".to_string());

661

662

// Add it to our full path string

663

current_path.push_str(format!("/{}", request.path).as_str());

664

// Get the specified path, return an error if it wasn't found.

665

let entry = match commit

666

.tree()

667

.unwrap()

668

.get_path(&PathBuf::from(request.path.clone()))

669

.map_err(|_| GitBackendError::PathNotFound(request.path.to_string()))

670

{

671

Ok(entry) => entry,

672

Err(err) => return Err(Box::new(err).into()),

673

};

674

675

// Find the file and turn it into our own struct

676

let file = match git.find_blob(entry.id()) {

677

Ok(blob) => RepositoryFile {

678

id: blob.id().to_string(),

679

content: blob.content().to_vec(),

680

binary: blob.is_binary(),

size: blob.size(),

},

Err(_) => {

return Err(Box::new(GitBackendError::BlobNotFound(entry.id().to_string())).into())

}

};

Ok((file, commit.id().to_string()))

689

}

690

691

async fn repository_commit_from_id(

692

&mut self,

693

requester: &Option<AuthenticatedUser>,

694

repository: &Repository,

695

request: &RepositoryCommitFromIdRequest,

696

) -> Result<Commit, Error> {

697

let git = self

698

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

699

.await?;

700

701

// Parse the passed object ids

702

let oid = git2::Oid::from_str(request.0.as_str())

703

.map_err(|_| GitBackendError::InvalidObjectId(request.0.clone()))?;

704

705

// Get the commit from the oid

706

let commit = git

707

.find_commit(oid)

708

.map_err(|_| GitBackendError::CommitNotFound(oid.to_string()))?;

709

710

Ok(Commit::from(commit))

711

}

712

713

async fn repository_last_commit_of_file(

714

&mut self,

715

requester: &Option<AuthenticatedUser>,

716

repository: &Repository,

717

request: &RepositoryLastCommitOfFileRequest,

718

) -> Result<Commit, Error> {

719

let git = self

720

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

721

.await?;

722

723

// Parse the passed object ids

724

let oid = git2::Oid::from_str(&request.start_commit)

725

.map_err(|_| GitBackendError::InvalidObjectId(request.start_commit.clone()))?;

726

727

// Get the commit from the oid

728

let commit = git

729

.find_commit(oid)

730

.map_err(|_| GitBackendError::CommitNotFound(oid.to_string()))?;

731

732

// Find the last commit of the file

733

let commit = GitBackend::get_last_commit_of_file(request.path.as_str(), &git, &commit)?;

Ok(commit)

}

/// Returns zero for all statistics if an OID wasn't found

739

async fn repository_get_statistics(

740

&mut self,

741

requester: &Option<AuthenticatedUser>,

742

repository: &Repository,

743

request: &RepositoryStatisticsRequest,

744

) -> Result<RepositoryStatistics, Error> {

745

let git = self

746

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

747

.await?;

748

749

let tree_id = match Self::get_oid_from_reference(&git, request.rev.as_deref()) {

750

Ok(oid) => oid,

751

Err(_) => return Ok(RepositoryStatistics::default()),

752

};

753

754

// Count the amount of branches and tags

755

let mut branches = 0;

756

let mut tags = 0;

757

if let Ok(references) = git.references() {

758

for reference in references.flatten() {

759

if reference.is_branch() {

760

branches += 1;

761

} else if reference.is_tag() {

tags += 1;

}

}

}

// Attempt to get the commit from the oid

768

let commits = if let Ok(commit) = git.find_commit(tree_id) {

769

// Get the total commit count if we found the tree oid commit

770

GitBackend::get_total_commit_count(&git, &commit)?

} else {

0

};

Ok(RepositoryStatistics {

commits,

branches,

tags,

})

}

async fn repository_get_branches(

783

&mut self,

784

requester: &Option<AuthenticatedUser>,

785

repository: &Repository,

786

request: &RepositoryBranchesRequest,

787

) -> Result<Vec<RepositoryBranch>, Error> {

788

let git = self

789

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

790

.await?;

791

792

// Could be done better with the RepositoryBranchFilter::None check done beforehand.

793

let mut filtered_branches = git

794

.branches(None)?

795

.filter_map(|branch| {

796

let branch = branch.ok()?.0;

797

798

let Some(name) = branch.name().ok().flatten() else {

return None;

};

// TODO: Non UTF-8?

let Some(commit) =

GitBackend::get_last_commit_in_rev(&git, branch.get().name().unwrap()).ok()

else {

return None;

};

// TODO: Implement stale with configurable age

810

let stale = false;

811

812

// Filter based on if the branch is stale or not

813

if request.filter != RepositoryBranchFilter::None {

814

#[allow(clippy::if_same_then_else)]

815

if stale && request.filter == RepositoryBranchFilter::Active {

816

return None;

817

} else if !stale && request.filter == RepositoryBranchFilter::Stale {

return None;

}

}

Some((name.to_string(), branch, stale, commit))

823

})

824

.collect::<Vec<_>>();

825

826

// Sort the branches by commit date

827

filtered_branches.sort_by(|(_, _, _, c1), (_, _, _, c2)| c2.time.cmp(&c1.time));

828

// Go to the requested position

829

let mut filtered_branches = filtered_branches.iter().skip(request.range.0);

830

831

let head = git.head()?;

832

let mut branches = vec![];

833

834

// Iterate through the filtered branches using the passed range

835

for _ in request.range.0..request.range.1 {

836

let Some((name, branch, stale, commit)) = filtered_branches.next() else {

break;

};

// Get how many commits are ahead of and behind of the head

841

let ahead_behind_head = if head.target().is_some() && branch.get().target().is_some() {

842

git.graph_ahead_behind(branch.get().target().unwrap(), head.target().unwrap())

.ok()

} else {

None

};

branches.push(RepositoryBranch {

849

850

stale: *stale,

851

last_commit: Some(commit.clone()),

ahead_behind_head,

})

}

Ok(branches)

}

async fn repository_diff(

860

&mut self,

861

requester: &Option<AuthenticatedUser>,

862

repository: &Repository,

863

request: &RepositoryDiffRequest,

864

) -> Result<RepositoryDiff, Error> {

865

let git = self

866

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

867

.await?;

868

869

// Parse the passed object ids

870

let oid_old = git2::Oid::from_str(request.old_id.as_str())

871

.map_err(|_| GitBackendError::InvalidObjectId(request.old_id.clone()))?;

872

let oid_new = git2::Oid::from_str(request.new_id.as_str())

873

.map_err(|_| GitBackendError::InvalidObjectId(request.new_id.clone()))?;

874

875

// Get the ids associates commits

876

let commit_old = git

877

.find_commit(oid_old)

878

.map_err(|_| GitBackendError::CommitNotFound(oid_old.to_string()))?;

879

let commit_new = git

880

.find_commit(oid_new)

881

.map_err(|_| GitBackendError::CommitNotFound(oid_new.to_string()))?;

882

883

// Get the commit trees

884

let tree_old = commit_old

885

.tree()

886

.map_err(|_| GitBackendError::TreeNotFound(oid_old.to_string()))?;

887

let tree_new = commit_new

888

.tree()

889

.map_err(|_| GitBackendError::TreeNotFound(oid_new.to_string()))?;

890

891

// Diff the two trees against each other

892

let diff = git

893

.diff_tree_to_tree(Some(&tree_old), Some(&tree_new), None)

894

.map_err(|_| {

895

GitBackendError::FailedDiffing(oid_old.to_string(), oid_new.to_string())

896

})?;

897

898

// Should be safe to unwrap?

899

let stats = diff.stats().unwrap();

900

let mut files: Vec<RepositoryDiffFile> = vec![];

901

902

diff.deltas().enumerate().for_each(|(i, delta)| {

903

// Parse the old file info from the delta

904

let old_file_info = match delta.old_file().exists() {

905

true => Some(RepositoryDiffFileInfo {

906

id: delta.old_file().id().to_string(),

path: delta

.old_file()

.path()

.unwrap()

.to_str()

.unwrap()

.to_string(),

size: delta.old_file().size(),

915

binary: delta.old_file().is_binary(),

}),

false => None,

};

// Parse the new file info from the delta

920

let new_file_info = match delta.new_file().exists() {

921

true => Some(RepositoryDiffFileInfo {

922

id: delta.new_file().id().to_string(),

path: delta

.new_file()

.path()

.unwrap()

.to_str()

.unwrap()

.to_string(),

size: delta.new_file().size(),

931

binary: delta.new_file().is_binary(),

}),

false => None,

};

let mut chunks: Vec<RepositoryDiffFileChunk> = vec![];

937

if let Some(patch) = git2::Patch::from_diff(&diff, i).ok().flatten() {

938

for chunk_num in 0..patch.num_hunks() {

939

if let Ok((chunk, chunk_num_lines)) = patch.hunk(chunk_num) {

940

let mut lines: Vec<RepositoryChunkLine> = vec![];

941

942

for line_num in 0..chunk_num_lines {

943

if let Ok(line) = patch.line_in_hunk(chunk_num, line_num) {

944

if let Ok(line_utf8) = String::from_utf8(line.content().to_vec()) {

945

lines.push(RepositoryChunkLine {

946

change_type: line.origin_value().into(),

947

content: line_utf8,

948

old_line_num: line.old_lineno(),

949

new_line_num: line.new_lineno(),

});

}

continue;

}

}

chunks.push(RepositoryDiffFileChunk {

958

header: String::from_utf8(chunk.header().to_vec()).ok(),

959

old_start: chunk.old_start(),

960

old_lines: chunk.old_lines(),

961

new_start: chunk.new_start(),

962

new_lines: chunk.new_lines(),

lines,

});

}

}

};

let file = RepositoryDiffFile {

970

status: RepositoryDiffFileStatus::from(delta.status()),

old_file_info,

new_file_info,

chunks,

};

files.push(file);

});

Ok(RepositoryDiff {

new_commit: Commit::from(commit_new),

981

files_changed: stats.files_changed(),

982

insertions: stats.insertions(),

983

deletions: stats.deletions(),

files,

})

}

async fn repository_diff_patch(

989

&mut self,

990

requester: &Option<AuthenticatedUser>,

991

repository: &Repository,

992

request: &RepositoryDiffPatchRequest,

993

) -> Result<String, Error> {

994

let git = self

995

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

996

.await?;

997

998

// Parse the passed object ids

999

let oid_old = git2::Oid::from_str(request.old_id.as_str())

1000

.map_err(|_| GitBackendError::InvalidObjectId(request.old_id.clone()))?;

1001

let oid_new = git2::Oid::from_str(request.new_id.as_str())

1002

.map_err(|_| GitBackendError::InvalidObjectId(request.new_id.clone()))?;

1003

1004

// Get the ids associates commits

1005

let commit_old = git

1006

.find_commit(oid_old)

1007

.map_err(|_| GitBackendError::CommitNotFound(oid_old.to_string()))?;

1008

let commit_new = git

1009

.find_commit(oid_new)

1010

.map_err(|_| GitBackendError::CommitNotFound(oid_new.to_string()))?;

1011

1012

// Get the commit trees

1013

let tree_old = commit_old

1014

.tree()

1015

.map_err(|_| GitBackendError::TreeNotFound(oid_old.to_string()))?;

1016

let tree_new = commit_new

1017

.tree()

1018

.map_err(|_| GitBackendError::TreeNotFound(oid_new.to_string()))?;

1019

1020

// Diff the two trees against each other

1021

let diff = git

1022

.diff_tree_to_tree(Some(&tree_old), Some(&tree_new), None)

1023

.map_err(|_| {

1024

GitBackendError::FailedDiffing(oid_old.to_string(), oid_new.to_string())

1025

})?;

1026

1027

// Print the entire patch

1028

let mut patch = String::new();

1029

1030

diff.print(git2::DiffFormat::Patch, |_, _, line| {

1031

match line.origin() {

1032

'+' | '-' | ' ' => patch.push(line.origin()),

1033

_ => {}

1034

}

1035

patch.push_str(std::str::from_utf8(line.content()).unwrap());

true

})

.unwrap();

Ok(patch)

}

async fn repository_commit_before(

1044

&mut self,

1045

requester: &Option<AuthenticatedUser>,

1046

repository: &Repository,

1047

request: &RepositoryCommitBeforeRequest,

1048

) -> Result<Commit, Error> {

1049

let git = self

1050

.open_repository_and_check_permissions(&repository.owner, &repository.name, requester)

1051

.await?;

1052

1053

// Parse the passed object id

1054

let oid = match git2::Oid::from_str(request.0.as_str()) {

1055

Ok(oid) => oid,

1056

Err(_) => {

1057

return Err(Box::new(GitBackendError::InvalidObjectId(request.0.clone())).into())

}

};

// Find the commit using the parsed oid

1062

let commit = match git.find_commit(oid) {

1063

Ok(commit) => commit,

1064

Err(_) => return Err(Box::new(GitBackendError::CommitNotFound(oid.to_string())).into()),

1065

};

1066

1067

// Get the first parent it has

1068

let parent = commit.parent(0);

1069

if let Ok(parent) = parent {

1070

return Ok(Commit::from(parent));

1071

} else {

1072

// TODO: See if can be done better

1073

// Walk through the repository commit graph starting at our current commit

1074

let mut revwalk = git.revwalk()?;

1075

revwalk.set_sorting(git2::Sort::TIME)?;

1076

revwalk.push(commit.id())?;

1077

1078

if let Some(Ok(before_commit_oid)) = revwalk.next() {

1079

// Find the commit using the parsed oid

1080

if let Ok(before_commit) = git.find_commit(before_commit_oid) {

1081

return Ok(Commit::from(before_commit));

}

}

Err(Box::new(GitBackendError::CommitParentNotFound(oid.to_string())).into())

}

}

}

impl IssuesBackend for GitBackend {

1091

fn issues_count(

1092

&mut self,

1093

_requester: &Option<AuthenticatedUser>,

1094

_request: &RepositoryIssuesCountRequest,

1095

) -> Result<u64, Error> {

todo!()

}

fn issue_labels(

&mut self,

_requester: &Option<AuthenticatedUser>,

1102

_request: &RepositoryIssueLabelsRequest,

1103

) -> Result<Vec<IssueLabel>, Error> {

todo!()

}

fn issues(

&mut self,

_requester: &Option<AuthenticatedUser>,

1110

_request: &RepositoryIssuesRequest,

1111

) -> Result<Vec<RepositoryIssue>, Error> {

todo!()

}

}

#[allow(unused)]

#[derive(Debug, sqlx::FromRow)]

1118

struct RepositoryMetadata {

1119

pub repository: String,

pub name: String,

pub value: String,

}