self._distval = None

          # The distvar rpm value

          self._distvar = None

          self._epoch = None

          # An authenticated buildsys session

          self._kojisession = None

          self._localarch = None

          # A property to load the mock config

          self._mockconfig = None

          self._module_name = None

          # The dist git namespace

          self._ns = None

          self._nvr = None

          self._rel = None

          # The cloned repo object

          self._repo = None

          # The rpm defines used when calling rpm

          self._rpmdefines = None

          self._spec = None

          # The build target within the buildsystem

          self._target = target

          self._password = None

          # The alternate Koji user to run commands as

          self._runas = None

          self._ver = None

          self.log = log

          # Pushurl or url of remote of branch

          # package name will be sent to lookaside CGI script as 'namespace/name'

          # instead of just name.

          self.lookaside_namespaced = lookaside_namespaced

      # Define properties here

      # Properties allow us to "lazy load" various attributes, which also means

      @property

      def localarch(self):

          if not self._localarch:

              self.load_localarch()

          self._mockconfig = '%s-%s' % (self.target, self.localarch)

      @property

      def module_name(self):

          """This property ensures the module attribute"""

      @module_name.setter

      def module_name(self, module_name):

      def load_module_name(self):

          try:

              if self.push_url:

                  # FIXME

                  # if self.distgit_namespaced:

                  #     self._module_name = "/".join(parts.path.split("/")[-2:])

                  return

          except rpkgError:

          self.load_nameverrel()

              return

      @property

      def ns(self):

          if not self._ns:

              self.load_ns()

      @property

      def ns_module_name(self):

          if self.distgit_namespaced:

          else:

      @property

      def nvr(self):

      def load_nvr(self):

          """This sets the nvr attribute"""

      @property

      def rel(self):

          return(self._rel)

      def load_nameverrel(self):

          cmd = ['rpm']

          cmd.extend(self.rpmdefines)

                  self.log.debug(joined_cmd)

                  self.log.error(err)

              raise rpkgError('Could not query n-v-r of %s: %s'

          if err:

              self.log.debug('Errors occoured while running following command to get N-V-R-E:')

              self.log.debug(joined_cmd)

          if len(parts) != 4:

              raise rpkgError('Could not get n-v-r-e from %r'

                              % first_line_output)

           self._epoch,

           self._ver,

           self._rel) = parts

      @property

      def spec(self):

          if not self._spec:

              self.load_spec()

      @property

      def mock_results_dir(self):

                              self.ver, self.rel)

      @property

          return (name, files, uploadfiles)

          :rtype: str

          """

          if self.distgit_namespaced:

              else:

                  # Default to rpms namespace for backwards compat

          else:

          return giturl

          :rtype: str

          """

          if self.distgit_namespaced:

              else:

                  # Default to rpms namespace for backwards compat

          else:

          return giturl

          self.log.info('Tag \'%s\' was created', tagname)

      def clean(self, dry=False, useignore=True):

          :param bool dry: Can optionally perform a dry-run. Defaults to `False`.

          :param bool useignore: Can optionally not use the ignore rules.

          self._run_command(cmd, cwd=self.path)

          return

                anon=False, target=None):

          """Clone a repo, optionally check out a specific branch.

          :param str path: an optional basedir to perform the clone in.

          :param str branch: an optional name of a branch to checkout instead of

              `<remote>/master`.

              self._branch_remote = None

          # construct the git url

          if anon:

          else:

          # Create the command

          cmd = ['git', 'clone']

          self._run_command(cmd, cwd=path)

          conf_git = git.Git(os.path.join(path, git_dir))

          return

          # Example:

          #       The path will just be os.path.join(path, "cockpit")

          """Clone a repo old style with subdirs for each branch.

          :param bool anon: whether or not to clone anonymously. Defaults to

              `False`.

          :param str target: an optional name of the folder in which to clone the

          self._branch_remote = None

          # Get the full path of, and git object for, our directory of branches

          top_path = os.path.join(self.path,

          top_git = git.Git(top_path)

          repo_path = os.path.join(top_path, 'rpkg.git')

          # construct the git url

          if anon:

          else:

          # Create our new top directory

          try:

              os.mkdir(top_path)

          except OSError as e:

          # Create a bare clone first. This gives us a good list of branches

          try:

          except Exception as e:

              # Clean out our directory

              shutil.rmtree(top_path)

          # We don't need this now. Ignore errors since keeping it does no harm

          shutil.rmtree(repo_path, ignore_errors=True)

          # Inject ourselves as the git credential helper for https pushing

          conf_git.config('credential.helper', ' '.join(find_me() + ['gitcred']))

          conf_git.config('credential.useHttpPath', 'true')

          # Set any other clone_config

          if self.clone_config:

              clone_config = self.clone_config.strip() % {

              for confline in clone_config.splitlines():

                  if confline:

                      conf_git.config(*confline.split())

      def commit(self, message=None, file=None, files=[], signoff=False):

          Requires the caller be a real tty or a message passed.

              module base directory.

          """

          oldpath = os.getcwd()

          os.chdir(self.path)

          # build up the command

          os.chdir(oldpath)

          return

          # This is stupid that I have to use subprocess :/

          # This cmd below only works to scratch build rawhide

          # We need something better for epel

          cmd = ['git', 'ls-remote', url, 'refs/heads/%s' % branch]

              raise rpkgError(e)

          if error:

              raise rpkgError('Got an error finding %s head for %s: %s'

          # Return the hash sum

          if not output:

              raise rpkgError('Could not find remote branch %s for %s'

          return output.split()[0]

      def gitbuildhash(self, build):

                  except ValueError:

                      pass

          oldpath = os.getcwd()

          os.chdir(self.path)

          """

          # Create the outfile name based on arguments

          # If we want to rediff, the patch file has to already exist

          if rediff and not os.path.exists(os.path.join(self.path, outfile)):

          # See if there is a source dir to diff in

          if not os.path.isdir(os.path.join(self.path,

                                                       self.ver))):

              raise rpkgError('Expanded source dir not found!')

          # Setup the command

                 '.%s' % suffix]

          # Try to run the command and capture the output

              self.log.info("sources file doesn't exist. Source files download skipped.")

              return

          if not outdir:

              outdir = self.path

          for entry in sourcesf.entries:

              outfile = os.path.join(outdir, entry.file)

              self.lookasidecache.download(

                  entry.file, entry.hash, outfile,

                  hashtype=entry.hashtype, **args)

              raise rpkgError('Packages in destination tag %(dest_tag_name)s are not inherited by'

                              ' build tag %(build_tag_name)s' % build_target)

          """Construct build URL with namespaced anongiturl and commit hash

          :param str commit_hash: the commit hash appended to build URL. It

              omitted, the latest commit hash got from current repository will be

              used.

          :rtype: str

          """

          return '{0}#{1}'.format(

              commit_hash or self.commithash)

      def build(self, skip_tag=False, scratch=False, background=False,

                url=None, chain=None, arches=None, sets=False, nvr_check=True):

          skip_tag: Skip the tag action after the build

                                    ' care that I am not able to construct NVR.'

                                    '  I will refer this build by package name'

                                    ' in following messages.')

          # see if this build has been done.  Does not check builds within

          # a chain

              clog.writelines(clog_lines)

      def compile(self, arch=None, short=False, builddir=None, nocheck=False):

          optionally for a specific arch, or short-circuit it, or

          define an alternate builddir

          self.kojisession.uploadWrapper(file, path, callback=callback)

      def install(self, arch=None, short=False, builddir=None, nocheck=False):

          optionally for a specific arch, short-circuit it, or

          define an alternative builddir

          """

          # Check for srpm

          if not os.path.exists(os.path.join(self.path, srpm)):

              log.warning('No srpm found')

          if not rpms:

              log.warning('No rpm found')

          cmd = ['rpmlint']

          if info:

              cmd.extend(['-i'])

          if rpmlintconf:

              gitignore.add('/%s' % file_basename)

              self.lookasidecache.upload(

                  f, file_hash)

          sourcesf.write()

          self.repo.index.add(['sources', '.gitignore'])

      def prep(self, arch=None, builddir=None):

          :param str arch: optional to run prep section for a specific arch. By

              default, local system arch will be used.

          self._run_command(cmd, shell=True)

      def srpm(self, hashtype=None):

          Requires sources already downloaded. The generated SRPM file will be

          put into package repository directory.

          self.srpmname = os.path.join(self.path,

                                       "%s-%s-%s.src.rpm"

          # See if we need to build the srpm

          if os.path.exists(self.srpmname):

          else:

              spec = data

          # Replace %{name} with the package name

          # Replace %{version} with the package version

          spec = spec.replace("%{version}", self.ver)

          return [line_num, offset - offset_inc + 1]

      def verify_files(self, builddir=None):

          :param str builddir: optionally define an alternate builddir.

          """

              # If the scm_url isn't specified, get the remote git URL of the

              # git repo the current user is in

              actual_scm_url = self._get_namespace_anongiturl(

              actual_scm_url = '{0}?#{1}'.format(actual_scm_url, self.commithash)

          return actual_scm_url, actual_branch

      return value

  # Adds `allow_abbrev' feature

  class _ArgumentParser(argparse.ArgumentParser):

      def __init__(self, *args, **kwargs):

              raise rpkgError('Missing kojiconfig and kojiprofile to load Koji '

                              'session. One of them must be specified.')

          # Create the cmd object

          self._cmd = self.site.Commands(self.args.path,

                                         items['lookaside'],

                                         )

          if self.args.module_name:

              if '/' not in self.args.module_name:

                  if dg_namespaced:

                      # No slash, assume rpms namespace

                      self._cmd.ns = 'rpms'

              else:

          self._cmd.password = self.args.password

          self._cmd.runas = self.args.runas

          self._cmd.debug = self.args.debug

          self._cmd.verbose = self.args.v

          self._cmd.lookaside_request_params = items.get('lookaside_request_params')

      # This function loads the extra stuff once we figure out what site

      # we are

      def do_imports(self, site=None):

                                  'for a while for backward-compatibility. It will be disabled'

                                  ' in future version.')

          # Allow forcing the package name

          # Override the  discovered user name

          self.parser.add_argument('--user', default=None,

                                   help='Override the discovered user name')

          """Register the clone target and co alias"""

          clone_parser = self.subparsers.add_parser(

          # Allow an old style clone with subdirs for branches

          clone_parser.add_argument(

              '--branches', '-B', action='store_true',

              help='Check out a module anonymously')

          # store the module to be cloned

          clone_parser.add_argument(

          # Eventually specify where to clone the module

          clone_parser.add_argument(

              "clone_target", default=None, nargs="?",

          clone_parser.set_defaults(command=self.clone)

          # Add an alias for historical reasons

      def clone(self):

          if self.args.branches:

                                       anon=self.args.anonymous,

                                       target=self.args.clone_target)

          else:

                             branch=self.args.branch,

                             anon=self.args.anonymous,

                             target=self.args.clone_target)

          # Parse the args

          self.args = self.parser.parse_args()