if mock_config is None or mock_config is False:

              cmd = 'LANG=C rpmbuild -%s %s > %s 2>&1' % (rpmarg,

                  specname, self.buildlog)

              self.outcode = subprocess.call(cmd, shell=True)

          else:

              cmd = 'LANG=C rpmbuild -bs %s > %s 2>&1' % (

                  specname, self.buildlog)

              self.outcode = subprocess.call(cmd, shell=True)

              self.get_rpm()

                      mock_resultdir, name)

              cmd = 'LANG=C %s >> %s.build.log 2>&1' % (

                  mockcommand, specname)

              self.outcode = subprocess.call(cmd, shell=True)

              if self.outcode == 30:

                  # When mock stop while building the cache, then check

                  directory = get_mock_root()

                  self.buildlog = '/%s/%s-%s/result/%s' % (

                      directory, mock_config, name, filename)

      def get_rpm(self):

          """ Parses the build.log to extract the rpm generated.

                      else:

                          self.rpm.append(rpm)

          except IOError as err:

      def remove_logs(self):

          """ Remove the log file generated while building the RPM. """

              stream.close()

          except IOError as err:

              self.log.info('An error occured during the build')

              print('Stopping')

              return(1)

          """

          specfile = self.spec.get_specfile()

          if self.build.outcode == 0:

              # Get the list of rpm generated

              self.build.get_rpm()

              print("RPM generated:")

              # Generate the spec file

              self.pack = super(R2rpm, self).main(args)

          else:

          if args.package or args.url:

              self.pack.download(args.force_dl)

                      self.__check_build_output()

              except BuildDepencenciesError as err:

                  print('Missing dependencies to build %s' % self.pack.name)

                  return 1

              except BuildError as err:

                  print('An error occured during the build of %s' % self.pack.name)

                  return 1

          if not args.keep_logs:

              self.build.remove_logs()

          sourcemotif = re.compile(r"Package:\s+%s\n" % name)

          result = sourcemotif.search(content)

          if result is not None:

              versionmotif = re.compile(r"Package:\s+%s\nVersion:(.*)" % name)

              version = versionmotif.search(content).group(1).strip()

              return (version)

          else:

      except IOError as ex:

          print('Could not contact the repository at url: %s' % url)

      return None

          url = self.source0.rsplit('/', 1)[0]

          url = '%s/%s' % (url, self.source)

          remotefile = urllib_request.urlopen(url)

          with open(sources, 'wb') as localfile:

          """ Extract the sources into the current directory. """

          sourcedir = get_rpm_tag('_sourcedir')

          tarball = "%s/%s" % (sourcedir, self.source)

          try:

              tar = tarfile.open(tarball)

              tar.extractall()

              tar.close()

          except TarError as err:

              self.log.debug("Error while extracting the tarball")

      def get(self, key):

          """ Retrieve the given key from the description information known

          from in them.

          """

          description = '%s/DESCRIPTION' % self.name

          if os.path.exists(self.name) and os.path.isfile(description):

              try:

                  stream = open(description, 'r')

                  stream.close()

              except IOError as err:

                  self.log.info(

              key = None

              for row in content.split('\n'):

                  if row.strip():

                          self.description[key] = self.description[key] + ' ' + \

                              row.strip()

          else:

      def read_config(self):

          """ Read the general configuration containing the repo information

          """ Remove the source we extracted in the current working

          directory.

          """

          try:

              shutil.rmtree(self.name)

          except (IOError, OSError) as err:

      def search_package_in_repo(self):

          """ Search a package in all R repositories listed in the general

                      break

          if version is None:

              self.log.info(

              raise R2specError(

              'Could not find package "%s" in any of the configured repos' \

                  % self.name)

              mytemplate = Template(tplfile)

              self.spec = mytemplate.render(self.__dict)

          except IOError as err:

              raise R2specError('Cannot read the file %s' % template)

      def get_specfile(self):

          """

          specfile = self.get_specfile()

          if os.path.exists(specfile) and os.path.isfile(specfile):

              try:

                  stream = open(specfile, 'r')

                  self.spec = stream.read()

                  stream.close()

              except IOError as err:

      def write_spec(self, verbose=False):

          """ Write down the spec to the spec directory as returned by rpm.

          """

          specfile = self.get_specfile()

          try:

              stream = open(specfile, 'w')

              stream.write(self.spec)

              stream.close()

              if verbose:

                  print('Spec file writen: %s' % specfile)

          except IOError as err: