Djam/artmigrator
1
0
Fork 0
mirror of https://tvoygit.ru/Djam/artmigrator.git synced 2025-02-23 10:22:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

update

Browse source
This commit is contained in:
Sergey Zhemoytel 2024-11-21 14:20:10 +03:00
parent cb816f8d66
commit f40022f203
5 changed files with 268 additions and 229 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
config.yaml.template
View file

@ -2,6 +2,7 @@ nexus:
url: "http://127.0.0.1:8081"
username: "your-nexus-username"
password: "your-nexus-password"
repository: "my-repository"
gitea:
url: "http://127.0.0.1:3000"

47
config/config.go
View file

@ -1,35 +1,36 @@
package config
import (
"os"
"os"
"gopkg.in/yaml.v3"
"gopkg.in/yaml.v3"
)
type Config struct {
Nexus struct {
URL string `yaml:"url"`
Username string `yaml:"username"`
Password string `yaml:"password"`
} `yaml:"nexus"`
Gitea struct {
URL string `yaml:"url"`
Token string `yaml:"token"`
Username string `yaml:"username"`
Repo string `yaml:"repo"`
} `yaml:"gitea"`
Nexus struct {
URL string `yaml:"url"`
Username string `yaml:"username"`
Password string `yaml:"password"`
Repository string `yaml:"repository"`
} `yaml:"nexus"`
Gitea struct {
URL string `yaml:"url"`
Token string `yaml:"token"`
Username string `yaml:"username"`
Repo string `yaml:"repo"`
} `yaml:"gitea"`
}
func LoadConfig(filename string) (*Config, error) {
data, err := os.ReadFile(filename)
if err != nil {
return nil, err
}
data, err := os.ReadFile(filename)
if err != nil {
return nil, err
}
var config Config
err = yaml.Unmarshal(data, &config)
if err != nil {
return nil, err
}
return &config, nil
var config Config
err = yaml.Unmarshal(data, &config)
if err != nil {
return nil, err
}
return &config, nil
}

125
core/core.go
View file

@ -1,73 +1,94 @@
package core
import (
"flag"
"log"
"flag"
"log"
"strings"
"tvoygit.ru/djam/artmigrator/config"
"tvoygit.ru/djam/artmigrator/repository/gitea"
"tvoygit.ru/djam/artmigrator/repository/nexus"
"tvoygit.ru/djam/artmigrator/config"
"tvoygit.ru/djam/artmigrator/repository/gitea"
"tvoygit.ru/djam/artmigrator/repository/nexus"
)
type App struct {
Config *config.Config
Config *config.Config
}
func NewApp(configFile string) (*App, error) {
log.Println("Загрузка конфигурации из файла", configFile)
cfg, err := config.LoadConfig(configFile)
if err != nil {
return nil, err
}
log.Println("Загрузка конфигурации из файла", configFile)
cfg, err := config.LoadConfig(configFile)
if err != nil {
return nil, err
}
flag.StringVar(&cfg.Nexus.URL, "nexus-url", cfg.Nexus.URL, "Nexus URL")
flag.StringVar(&cfg.Nexus.Username, "nexus-username", cfg.Nexus.Username, "Nexus Username")
flag.StringVar(&cfg.Nexus.Password, "nexus-password", cfg.Nexus.Password, "Nexus Password")
flag.StringVar(&cfg.Gitea.URL, "gitea-url", cfg.Gitea.URL, "Gitea URL")
flag.StringVar(&cfg.Gitea.Token, "gitea-token", cfg.Gitea.Token, "Gitea Token")
flag.Parse()
flag.StringVar(&cfg.Nexus.URL, "nexus-url", cfg.Nexus.URL, "Nexus URL")
flag.StringVar(&cfg.Nexus.Username, "nexus-username", cfg.Nexus.Username, "Nexus Username")
flag.StringVar(&cfg.Nexus.Password, "nexus-password", cfg.Nexus.Password, "Nexus Password")
flag.StringVar(&cfg.Gitea.URL, "gitea-url", cfg.Gitea.URL, "Gitea URL")
flag.StringVar(&cfg.Gitea.Token, "gitea-token", cfg.Gitea.Token, "Gitea Token")
flag.Parse()
return &App{Config: cfg}, nil
return &App{Config: cfg}, nil
}
func (a *App) Run() error {
log.Println("Начало процесса загрузки артефакта")
log.Println("Начало процесса загрузки артефакта")
nexusClient := nexus.NewClient(a.Config.Nexus.URL, a.Config.Nexus.Username, a.Config.Nexus.Password)
log.Println("Авторизация в Nexus прошла успешно")
nexusClient := nexus.NewClient(a.Config.Nexus.URL, a.Config.Nexus.Username, a.Config.Nexus.Password)
log.Println("Авторизация в Nexus прошла успешно")
giteaClient := gitea.NewClient(a.Config.Gitea.URL, a.Config.Gitea.Token, a.Config)
log.Println("Авторизация в Gitea прошла успешно")
giteaClient := gitea.NewClient(a.Config.Gitea.URL, a.Config.Gitea.Token, a.Config)
log.Println("Авторизация в Gitea прошла успешно")
repository := "your-repository-name"
log.Println("Начало процесса загрузки артефактов...")
artifacts, err := nexusClient.GetArtifacts(repository)
if err != nil {
return err
}
log.Printf("Найдены артефакты для загрузки в Gitea: %v", artifacts)
repository := a.Config.Nexus.Repository
log.Println("Начало процесса загрузки артефактов...")
artifacts, err := nexusClient.GetArtifacts(repository)
if err != nil {
return err
}
log.Printf("Найдены артефакты для загрузки в Gitea: %v", artifacts)
if len(artifacts) == 0 {
log.Println("Нет артефактов для загрузки в Gitea")
} else {
for _, artifact := range artifacts {
log.Printf("Загрузка артефакта %s из репозитория Nexus...", artifact)
data, err := nexusClient.GetArtifactData(repository, artifact)
if err != nil {
log.Printf("Ошибка загрузки артефакта %s: %v", artifact, err)
continue
}
log.Printf("Артефакт %s загружен из репозитория Nexus", artifact)
if len(artifacts) == 0 {
log.Println("Нет артефактов для загрузки в Gitea")
} else {
for _, artifact := range artifacts {
log.Printf("Загрузка артефакта %s из репозитория Nexus...", artifact)
data, err := nexusClient.GetArtifactData(repository, artifact)
if err != nil {
log.Printf("Ошибка загрузки артефакта %s: %v", artifact, err)
continue
}
log.Printf("Артефакт %s загружен из репозитория Nexus", artifact)
log.Printf("Загрузка артефакта %s в репозиторий Gitea...", artifact)
err = giteaClient.UploadArtifact(artifact, data)
if err != nil {
log.Printf("Ошибка загрузки артефакта %s в Gitea: %v", artifact, err)
} else {
log.Printf("Артефакт %s успешно загружен в Gitea", artifact)
}
}
}
log.Println("Процесс загрузки артефактов завершен.")
return nil
// Изменение функции Run для загрузки артефактов в Gitea
parts := strings.Split(artifact, "/")
if len(parts) < 4 {
log.Printf("Некорректный формат артефакта %s", artifact)
continue
}
groupId := parts[0]
artifactId := parts[1]
version := parts[2]
fileParts := strings.Split(parts[3], ".")
if len(fileParts) < 2 {
log.Printf("Некорректный формат файла %s", parts[3])
continue
}
if fileParts[len(fileParts)-1] == "md5" || fileParts[len(fileParts)-1] == "sha1" {
log.Printf("Пропускаем файл %s, так как он имеет расширение .md5 или .sha1", artifact)
continue
}
packaging := fileParts[len(fileParts)-1]
log.Printf("Загрузка артефакта %s в репозиторий Gitea...", artifact)
err = giteaClient.UploadArtifact(groupId, artifactId, version, packaging, data)
if err != nil {
log.Printf("Ошибка загрузки артефакта %s в Gitea: %v", artifact, err)
} else {
log.Printf("Артефакт %s успешно загружен в Gitea", artifact)
}
}
}
log.Println("Процесс загрузки артефактов завершен.")
return nil
}

159
repository/gitea/gitea.go
View file

@ -1,106 +1,109 @@
package gitea
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
"tvoygit.ru/djam/artmigrator/config"
"tvoygit.ru/djam/artmigrator/logger"
"tvoygit.ru/djam/artmigrator/config"
"tvoygit.ru/djam/artmigrator/logger"
)
type Client struct {
BaseURL string
HTTPClient *http.Client
Token string
Config *config.Config
BaseURL string
HTTPClient *http.Client
Token string
Config *config.Config
}
func NewClient(baseURL, token string, config *config.Config) *Client {
return &Client{
BaseURL: baseURL,
HTTPClient: &http.Client{},
Token: token,
Config: config,
}
return &Client{
BaseURL: baseURL,
HTTPClient: &http.Client{},
Token: token,
Config: config,
}
}
func (c *Client) ArtifactExists(artifact string) (bool, error) {
log.Printf("Проверка наличия артефакта %s в репозитории Gitea", artifact)
url := fmt.Sprintf("%s/api/v1/repos/%s/%s/contents/%s", c.BaseURL, c.Config.Gitea.Username, c.Config.Gitea.Repo, artifact)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return false, err
}
req.Header.Add("Authorization", fmt.Sprintf("token %s", c.Token))
log.Printf("Проверка наличия артефакта %s в репозитории Gitea", artifact)
url := fmt.Sprintf("%s/api/v1/repos/%s/%s/contents/%s", c.BaseURL, c.Config.Gitea.Username, c.Config.Gitea.Repo, artifact)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return false, err
}
req.Header.Add("Authorization", fmt.Sprintf("token %s", c.Token))
resp, err := c.HTTPClient.Do(req)
if err != nil {
return false, err
}
defer resp.Body.Close()
resp, err := c.HTTPClient.Do(req)
if err != nil {
return false, err
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusNotFound {
log.Printf("Артефакт %s не существует в репозитории Gitea", artifact)
return false, nil
}
if resp.StatusCode == http.StatusNotFound {
log.Printf("Артефакт %s не существует в репозитории Gitea", artifact)
return false, nil
}
log.Printf("Артефакт %s существует в репозитории Gitea", artifact)
return true, nil
log.Printf("Артефакт %s существует в репозитории Gitea", artifact)
return true, nil
}
type UploadArtifactRequest struct {
Content string `json:"content"`
Message string `json:"message"`
Content string `json:"content"`
Message string `json:"message"`
}
func (c *Client) UploadArtifact(artifactPath string, data []byte) error {
log.Printf("Загрузка артефакта %s в репозиторий Gitea", artifactPath)
url := fmt.Sprintf("%s/api/v1/repos/%s/%s/contents/%s?ref=master", c.BaseURL, c.Config.Gitea.Username, c.Config.Gitea.Repo, artifactPath)
request := UploadArtifactRequest{
Content: string(data),
Message: "Upload artifact",
}
jsonRequest, err := json.Marshal(request)
if err != nil {
return err
}
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonRequest))
if err != nil {
return err
}
req.Header.Add("Authorization", fmt.Sprintf("token %s", c.Token))
req.Header.Add("Content-Type", "application/json")
func (c *Client) UploadArtifact(groupId, artifactId, version, packaging string, data []byte) error {
log.Printf("Загрузка артефакта %s-%s-%s.%s в репозиторий Gitea", groupId, artifactId, version, packaging)
url := fmt.Sprintf("%s/api/v1/packages/%s/maven", c.BaseURL, c.Config.Gitea.Repo)
request := map[string]string{
"groupId": groupId,
"artifactId": artifactId,
"version": version,
"packaging": packaging,
"file": fmt.Sprintf("%s-%s-%s.%s", artifactId, version, packaging, packaging),
}
jsonRequest, err := json.Marshal(request)
if err != nil {
return err
}
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonRequest))
if err != nil {
return err
}
req.Header.Add("Authorization", fmt.Sprintf("token %s", c.Token))
req.Header.Add("Content-Type", "application/json")
logger.Logger.Printf("Upload artifact request: %s", req.URL)
logger.Logger.Printf("Upload artifact headers: %v", req.Header)
logger.Logger.Printf("Upload artifact body: %s", jsonRequest)
logger.Logger.Printf("Upload artifact request: %s", req.URL)
logger.Logger.Printf("Upload artifact headers: %v", req.Header)
logger.Logger.Printf("Upload artifact body: %s", jsonRequest)
resp, err := c.HTTPClient.Do(req)
if err != nil {
logger.Logger.Printf("Upload artifact error: %v", err)
return err
}
defer resp.Body.Close()
resp, err := c.HTTPClient.Do(req)
if err != nil {
logger.Logger.Printf("Upload artifact error: %v", err)
return err
}
defer resp.Body.Close()
logger.Logger.Printf("Upload artifact response status code: %d", resp.StatusCode)
logger.Logger.Printf("Upload artifact response headers: %v", resp.Header)
logger.Logger.Printf("Upload artifact response status code: %d", resp.StatusCode)
logger.Logger.Printf("Upload artifact response headers: %v", resp.Header)
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
logger.Logger.Printf("Upload artifact error reading response body: %v", err)
return err
}
logger.Logger.Printf("Upload artifact response body: %s", body)
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
logger.Logger.Printf("Upload artifact error reading response body: %v", err)
return err
}
logger.Logger.Printf("Upload artifact response body: %s", body)
if resp.StatusCode != http.StatusCreated {
logger.Logger.Printf("Failed to upload artifact: %s", body)
return fmt.Errorf("failed to upload artifact")
}
if resp.StatusCode != http.StatusCreated {
logger.Logger.Printf("Failed to upload artifact: %s", body)
return fmt.Errorf("failed to upload artifact")
}
log.Printf("Артефакт %s загружен в репозиторий Gitea", artifactPath)
return nil
log.Printf("Артефакт %s-%s-%s.%s загружен в репозиторий Gitea", groupId, artifactId, version, packaging)
return nil
}

165
repository/nexus/nexus.go
View file

@ -1,104 +1,117 @@
package nexus
import (
"fmt"
"io/ioutil"
"log"
"net/http"
"strings"
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
)
type Client struct {
BaseURL string
HTTPClient *http.Client
Username string
Password string
BaseURL string
HTTPClient *http.Client
Username string
Password string
}
func NewClient(baseURL, username, password string) *Client {
return &Client{
BaseURL: baseURL,
HTTPClient: &http.Client{},
Username: username,
Password: password,
}
return &Client{
BaseURL: baseURL,
HTTPClient: &http.Client{},
Username: username,
Password: password,
}
}
func (c *Client) GetArtifacts(repository string) ([]string, error) {
log.Printf("Получение артефактов из репозитория Nexus")
url := fmt.Sprintf("%s/repository/%s/", c.BaseURL, repository)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err
}
req.SetBasicAuth(c.Username, c.Password)
url := fmt.Sprintf("%s/service/rest/v1/search/assets?sort=repository&repository=%s", c.BaseURL, repository)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err
}
req.SetBasicAuth(c.Username, c.Password)
resp, err := c.HTTPClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
log.Printf("Запрос на получение артефактов: %s", req.URL)
log.Printf("Заголовки запроса: %v", req.Header)
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
resp, err := c.HTTPClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
log.Printf("Артефакты получены из репозитория Nexus")
artifacts := strings.Split(string(body), "\n")
var result []string
for _, artifact := range artifacts {
if strings.Contains(artifact, ".jar") || strings.Contains(artifact, ".pom") {
result = append(result, artifact)
}
}
return result, nil
log.Printf("Код ответа: %d", resp.StatusCode)
log.Printf("Заголовки ответа: %v", resp.Header)
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
log.Printf("Тело ответа: %s", string(body))
var assets struct {
Items []struct {
DownloadUrl string `json:"downloadUrl"`
} `json:"items"`
}
err = json.Unmarshal(body, &assets)
if err != nil {
return nil, err
}
var result []string
for _, asset := range assets.Items {
result = append(result, asset.DownloadUrl)
}
return result, nil
}
func (c *Client) GetArtifactData(repository, artifact string) ([]byte, error) {
log.Printf("Загрузка артефакта %s из репозитория Nexus", artifact)
url := fmt.Sprintf("%s/repository/%s/%s", c.BaseURL, repository, artifact)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err
}
req.SetBasicAuth(c.Username, c.Password)
log.Printf("Загрузка артефакта %s из репозитория Nexus", artifact)
url := fmt.Sprintf("%s/repository/%s/%s", c.BaseURL, repository, artifact)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err
}
req.SetBasicAuth(c.Username, c.Password)
resp, err := c.HTTPClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
resp, err := c.HTTPClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
log.Printf("Артефакт %s загружен из репозитория Nexus", artifact)
return body, nil
log.Printf("Артефакт %s загружен из репозитория Nexus", artifact)
return body, nil
}
func (c *Client) ArtifactExists(artifact string) (bool, error) {
log.Printf("Проверка наличия артефакта %s в репозитории Nexus", artifact)
url := fmt.Sprintf("%s/repository/%s/%s", c.BaseURL, "your-repository-name", artifact)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return false, err
}
req.SetBasicAuth(c.Username, c.Password)
log.Printf("Проверка наличия артефакта %s в репозитории Nexus", artifact)
url := fmt.Sprintf("%s/repository/%s/%s", c.BaseURL, "your-repository-name", artifact)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return false, err
}
req.SetBasicAuth(c.Username, c.Password)
resp, err := c.HTTPClient.Do(req)
if err != nil {
return false, err
}
defer resp.Body.Close()
resp, err := c.HTTPClient.Do(req)
if err != nil {
return false, err
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusNotFound {
log.Printf("Артефакт %s не существует в репозитории Nexus", artifact)
return false, nil
}
if resp.StatusCode == http.StatusNotFound {
log.Printf("Артефакт %s не существует в репозитории Nexus", artifact)
return false, nil
}
log.Printf("Артефакт %s существует в репозитории Nexus", artifact)
return true, nil
log.Printf("Артефакт %s существует в репозитории Nexus", artifact)
return true, nil
}