File _service:obs_scm:obs-scm-bridge-1638458917.89d8... of Package obs_scm_bridge

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:obs-scm-bridge-1638458917.89d821e.obscpio of Package obs_scm_bridge (Revision 74b61d095b28c8f321ee6edf21ad406b)

Currently displaying revision 74b61d095b28c8f321ee6edf21ad406b , Show latest

07070100000000000081A400000000000000000000000161A8E625000001BD000000000000000000000000000000000000002B00000000obs-scm-bridge-1638458917.89d821e/Makefileprefix = /usr
PYTHON ?= python

servicedir = ${prefix}/lib/obs/service

all:

install:
	install -d $(DESTDIR)$(servicedir)
	install -m 0755 download_assets obs_scm_bridge $(DESTDIR)$(servicedir)
	install -m 0644 helpers.py $(DESTDIR)$(servicedir)

test:
	flake8 set_version tests/
	${PYTHON} -m unittest discover tests/

clean:
	find -name "*.pyc" -exec rm {} \;
	find -name '*.pyo' -exec rm {} \;
	rm -rf set_versionc

.PHONY: all install test
07070100000001000081A400000000000000000000000161A8E62500000631000000000000000000000000000000000000002C00000000obs-scm-bridge-1638458917.89d821e/README.md
Native OBS SCM bridge helper
============================

Native OBS scm support for the build recipies and additional files. This is bridging an external authorative
scm repository into OBS. Any source change or merge workflow must be provided via the scm repository 
hoster in this scenario.

Only git is supported atm, but this can be extended later to further systems.

It is not recommended to put large binary files into git directly as this won't scale. Use the
asset support instead, which is described in pbuild documentation:

http://opensuse.github.io/obs-build/pbuild.html#_remote_assets

These assets will be downloaded by osc and OBS. The verification via sha256 sum is optional.

HOWTO
=====

The current temporary way to define a git repository inside of an OBS package is to mis-used the title
element inside of the package meta. Set it to

GIT:<public_git_url>

For doing a local checkout use the currently experimental osc from

https://download.opensuse.org/repositories/home:/adrianSuSE:/OBSGIT/

This version allows you to do

# osc co $project <$package>

which will create a git repository inside of the classic osc checkout.

The only further tested functionality is to do local builds atm.

TODO
====

* Clean integration via a proper meta data defintion.

* Project level support: Packages are defined via a gitlab/github project.

* osc upstream integration

* find a better way to store files in .osc and .assets of the checkout, as
   they do not belong to the git repository
    auto extending .gitignore? (esp. when downloading asset files?)

07070100000002000081ED00000000000000000000000161A8E62500000A12000000000000000000000000000000000000003200000000obs-scm-bridge-1638458917.89d821e/download_assets#!/usr/bin/perl
################################################################
#
# Copyright (c) 2021 SUSE LLC
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 or 3 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program (see the file COPYING); if not, write to the
# Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#
################################################################

BEGIN {
  if (!$::ENV{'BUILD_DIR'} && $0 ne '-' && $0 ne '-e' && -e $0 && ! -e '/etc/build.conf') {
    use Cwd ();
    my $p = Cwd::abs_path($0);
    $::ENV{'BUILD_DIR'} = $p if $p =~ s/\/[^\/]+$// && $p ne '/usr/lib/build' && -d "$p/PBuild";
  }
  unshift @INC, ($::ENV{'BUILD_DIR'} && ! -e '/etc/build.conf' ? $::ENV{'BUILD_DIR'} : '/usr/lib/build');
}

use strict;

use Data::Dumper;
use POSIX;
use Cwd ();

use Build;

use PBuild::AssetMgr;
use PBuild::Source;

# FIXME: all code should become arch agnostic
my $arch = 'noarch';
my $global_asset_dir;

my @assetsurls = (
  'fedpkg@https://pkgs.fedoraproject.org/repo/pkgs',
);

my $bconf = Build::read_config($arch);
for my $dir (@ARGV) {
  my ($files, $asset_files) = PBuild::Source::list_package($dir);
  my @assets;
  my $assetdir = $global_asset_dir || "$dir/.assets";
  my $p = {
    'pkg' => "_me",
    'dir' => $dir,
    'files' => $files,
    'srcmd5' => PBuild::Source::calc_srcmd5($files),
  };
  $p->{'asset_files'} = $asset_files if %{$asset_files || {}};
 
  my $assetmgr = PBuild::AssetMgr::create($assetdir);
  $assetmgr->add_assetshandler($_) for @assetsurls;

for my $file (sort keys %$files) {
    if ($file eq 'sources') {
      $p->{'buildtype'} = '';
      $assetmgr->find_assets($p, $arch);
      next;
    }
    next unless $file eq 'PKGBUILD' || $file =~ /\.(?:spec|dsc|kiwi)/;
    my $bt = Build::recipe2buildtype($file);
    next unless $bt;
    $p->{'buildtype'} = $bt;
    my $d;
    eval { $d = Build::parse_typed($bconf, "$dir/$file", $bt) };
    $p->{'remoteassets'} = $d->{'remoteassets'} if $d && $d->{'remoteassets'};
    $assetmgr->find_assets($p, $arch);
  }
  $assetmgr->getremoteassets($p);
  $assetmgr->copy_assets($p, $dir);
}

07070100000003000081A400000000000000000000000161A8E6250000098A000000000000000000000000000000000000002D00000000obs-scm-bridge-1638458917.89d821e/helpers.pyfrom __future__ import print_function

import datetime
import os
import logging
import subprocess

# python3 renaming of StringIO
try:
    import StringIO
except:
    from io import StringIO

class Helpers():
    def run_cmd(self, cmd, cwd, interactive=False, raisesysexit=False):
        """
        Execute the command cmd in the working directory cwd and check return
        value. If the command returns non-zero and raisesysexit is True raise a
        SystemExit exception otherwise return a tuple of return code and
        command output.
        """
        logging.debug("COMMAND: %s" % cmd)

proc = subprocess.Popen(cmd,
                                shell=False,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.STDOUT,
                                cwd=cwd)
        output = ''
        if interactive:
            stdout_lines = []
            while proc.poll() is None:
                for line in proc.stdout:
                    line_str = line.rstrip().decode('UTF-8')
                    print(line_str)
                    stdout_lines.append(line_str)
            output = '\n'.join(stdout_lines)
            output = output
        else:
            output = proc.communicate()[0]
            if isinstance(output, bytes):
                output = output.decode('UTF-8')

if proc.returncode and raisesysexit:
            logging.info("ERROR(%d): %s", proc.returncode, repr(output))
            raise SystemExit(
                "Command %s failed(%d): '%s'" % (cmd, proc.returncode, output)
            )
        else:
            logging.debug("RESULT(%d): %s", proc.returncode, repr(output))

return (proc.returncode, output)

def safe_run(self, cmd, cwd, interactive=False):
        """Execute the command cmd in the working directory cwd and check return
        value. If the command returns non-zero raise a SystemExit exception.
        """
        result = self.run_cmd(cmd, cwd, interactive, raisesysexit=True)
        return result

def get_timestamp(self, scm_object, args, clone_dir):
        """Returns the commit timestamp for checked-out repository."""

timestamp = scm_object.get_timestamp()
        logging.debug("COMMIT TIMESTAMP: %s (%s)", timestamp,
                      datetime.datetime.fromtimestamp(timestamp).strftime(
                          '%Y-%m-%d %H:%M:%S'))
        return timestamp
07070100000004000081A400000000000000000000000161A8E62500000506000000000000000000000000000000000000003600000000obs-scm-bridge-1638458917.89d821e/obs-scm-bridge.spec#
# spec file
#
# Copyright (c) 2021 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
# upon. The license for this file, and modifications and additions to the
# file, is the same license as for the pristine package itself (unless the
# license for the pristine package is not an Open Source License, in which
# case the license is the MIT License). An "Open Source License" is a
# license that conforms to the Open Source Definition (Version 1.9)
# published by the Open Source Initiative.

# Please submit bugfixes or comments via https://bugs.opensuse.org/
#

%if 0%{?fedora} || 0%{?rhel}
%define build_pkg_name obs-build
%else
%define build_pkg_name build
%endif

Name:           obs-scm-bridge
Version:        0.0.1
Release:        0
Summary:        A help service to work with git repositories in OBS
License:        GPL-2.0-or-later
URL:            https://github.com/openSUSE/obs-scm-bridge
Source0:        %{name}-%{version}.tar.xz
Requires:       %{build_pkg_name} >= 20211125
BuildArch:      noarch
Recommends:     python3-packaging

%description

%prep
%autosetup

%build

%install
make DESTDIR=%{buildroot} install

%files
%{_prefix}/lib/obs/service

%changelog
07070100000005000081ED00000000000000000000000161A8E6250000107E000000000000000000000000000000000000003100000000obs-scm-bridge-1638458917.89d821e/obs_scm_bridge#!/usr/bin/python3
# -*- coding: utf-8 -*-

# scm (only git atm) cloning and packaging for Open Build Service
# 
# (C) 2021 by Adrian Schröter <adrian@suse.de>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
# See http://www.gnu.org/licenses/gpl-2.0.html for full license text.

from __future__ import print_function

import argparse
import glob
import os
import re
import shutil
import sys
import tarfile
import codecs
import logging
import subprocess

# copied from obs_scm for now
from helpers import Helpers

if os.environ.get('DEBUG_SET_VERSION') == "1":
    logging.getLogger().setLevel(logging.DEBUG)

outdir = None

class ObsGit(object):
    def __init__(self, outdir, url, revision=None):
        self.outdir   = outdir
        self.url      = url
        self.revision = revision
        self.helpers        = Helpers()

def clone(self):
        clone = [ 'git', 'clone', self.url, self.outdir ]
        os.environ['LANG'] = "C"
        self.helpers.run_cmd(clone, None)

def cpio_directory(self, directory):
        cmd = [ 'cpio', '--create', '--format=newc', '--owner', ':0', '--reproducible' ]
        logging.info("create archivefile for %s", directory)
        archivefile = open(directory + '.obscpio', 'w')

proc = subprocess.Popen(
            cmd,
            shell  = False,
            stdin  = subprocess.PIPE,
            stdout = archivefile
        )

for root, dirs, files in os.walk(directory, topdown=False):
            for name in dirs:
                proc.stdin.write(os.path.join(root, name).encode('UTF-8', 'surrogateescape'))
                proc.stdin.write(b"\n")

for name in files:
                proc.stdin.write(os.path.join(root, name).encode('UTF-8', 'surrogateescape'))
                proc.stdin.write(b"\n")

proc.stdin.close()
        ret_code = proc.wait()
        if ret_code != 0:
            raise SystemExit("Creating the cpio archive failed!")
        archivefile.close()

def cpio_directories(self):
        logging.debug("walk via %s", self.outdir)
        os.chdir(self.outdir)
        listing = os.listdir(".")
        for name in listing:
            if name == '.git':
                # we do not store git meta data service side atm to avoid bloat storage
                # however, this will break some builds, so we will need an opt-out in future
                shutil.rmtree(name)
                continue
            if name[0:1] == '.':
                # no dot directories by default
                continue
            if os.path.isdir(name):
                logging.info("CPIO %s ", name)
                self.cpio_directory(name)
                shutil.rmtree(name)

def get_assets(self):
        clone = [ '/usr/lib/obs/service/download_assets', self.outdir ]
        self.helpers.run_cmd(clone, None)

if __name__ == '__main__':

parser = argparse.ArgumentParser(
        description='Open Build Service source service for managing packaging files in git.'
        'This is a special service for OBS git integration.')
    parser.add_argument('--outdir', required=True,
                        help='output directory for modified sources')
    parser.add_argument('--url',
                        help='REQUIRED: url to git repository')
    parser.add_argument('--revision',
                        help='commit, tag or branch to use')
    parser.add_argument('--debug',
                        help='verbose debug mode')
    args = vars(parser.parse_args())

url = args['url']
    outdir = args['outdir']
    revision = args['revision']

if not outdir:
        print("no outdir specified")
        sys.exit(-1)

if not url:
        print("no url specified")
        sys.exit(-1)

if args['debug']:
        logging.getLogger().setLevel(logging.DEBUG)
        logging.debug("Running in debug mode")

# workflow
    obsgit = ObsGit(outdir, url)
    obsgit.clone()
    obsgit.get_assets()
    if os.environ.get('OBS_SERVICE_DAEMON'):
        obsgit.cpio_directories()

07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!27 blocks

Places

File _service:obs_scm:obs-scm-bridge-1638458917.89d821e.obscpio of Package obs_scm_bridge (Revision 74b61d095b28c8f321ee6edf21ad406b)

Places