docs: public void execute() throws MojoExecutionException {
  
          final MavenProject project = getProject();
  
          if (skip) {
              getLog().info("skipping as configured (skip)");
              return;
          }
  
          if (skipPOMs && isPOM()) {
              getLog().info("skipping because artifact is a pom (skipPOMs)");
              return;
          }
  
          if (skipSubmodules && isSubmodule()) {
              getLog().info("skipping submodule (skipSubmodules)");
              return;
          }
  
  
          setData(dataSet);
  
          console = new MojoConsole(getLog(), verbose);
  
          initializeSignProperties();
  
          final VariableResolver resolver = initializeVariableResolver(new HashMap<String, String>());
  
          final File debFile = new File(Utils.replaceVariables(resolver, deb, openReplaceToken, closeReplaceToken));
          final File controlDirFile = new File(Utils.replaceVariables(resolver, controlDir, openReplaceToken, closeReplaceToken));
          final File installDirFile = new File(Utils.replaceVariables(resolver, installDir, openReplaceToken, closeReplaceToken));
          final File changesInFile = new File(Utils.replaceVariables(resolver, changesIn, openReplaceToken, closeReplaceToken));
          final File changesOutFile = new File(Utils.replaceVariables(resolver, changesOut, openReplaceToken, closeReplaceToken));
          final File changesSaveFile = new File(Utils.replaceVariables(resolver, changesSave, openReplaceToken, closeReplaceToken));
          final File keyringFile = keyring == null ? null : new File(Utils.replaceVariables(resolver, keyring, openReplaceToken, closeReplaceToken));
  
          // if there are no producers defined we try to use the artifacts
          if (dataProducers.isEmpty()) {
  
              if (hasMainArtifact()) {
                  Set<Artifact> artifacts = new HashSet<Artifact>();
  
                  artifacts.add(project.getArtifact());
  
                  @SuppressWarnings("unchecked")
                  final Set<Artifact> projectArtifacts = project.getArtifacts();
  
                  for (Artifact artifact : projectArtifacts) {
                      artifacts.add(artifact);
                  }
  
                  @SuppressWarnings("unchecked")
                  final List<Artifact> attachedArtifacts = project.getAttachedArtifacts();
  
                  for (Artifact artifact : attachedArtifacts) {
                      artifacts.add(artifact);
                  }
  
                  for (Artifact artifact : artifacts) {
                      final File file = artifact.getFile();
                      if (file != null) {
                          dataProducers.add(new DataProducer() {
                              public void produce( final DataConsumer receiver ) {
                                  try {
                                      final File path = new File(installDirFile.getPath(), file.getName());
                                      final String entryName = path.getPath();
  
                                      final boolean symbolicLink = SymlinkUtils.isSymbolicLink(path);
                                      final TarArchiveEntry e;
                                      if (symbolicLink) {
                                          e = new TarArchiveEntry(entryName, TarConstants.LF_SYMLINK);
                                          e.setLinkName(SymlinkUtils.readSymbolicLink(path));
                                      } else {
                                          e = new TarArchiveEntry(entryName, true);
                                      }
  
                                      e.setUserId(0);
                                      e.setGroupId(0);
                                      e.setUserName("root");
                                      e.setGroupName("root");
                                      e.setMode(TarEntry.DEFAULT_FILE_MODE);
                                      e.setSize(file.length());
  
                                      receiver.onEachFile(new FileInputStream(file), e);
                                  } catch (Exception e) {
                                      getLog().error(e);
                                  }
                              }
                          });
                      } else {
                          getLog().error("No file for artifact " + artifact);
                      }
                  }
              }
          }
  
          try {
              DebMaker debMaker = new DebMaker(console, dataProducers, conffileProducers);
              debMaker.setDeb(debFile);
              debMaker.setControl(controlDirFile);
              debMaker.setPackage(getProject().getArtifactId());
              debMaker.setDescription(getProject().getDescription());
              debMaker.setHomepage(getProject().getUrl());
              debMaker.setChangesIn(changesInFile);
              debMaker.setChangesOut(changesOutFile);
              debMaker.setChangesSave(changesSaveFile);
              debMaker.setCompression(compression);
              debMaker.setKeyring(keyringFile);
              debMaker.setKey(key);
              debMaker.setPassphrase(passphrase);
              debMaker.setSignPackage(signPackage);
              debMaker.setSignChanges(signChanges);
              debMaker.setSignMethod(signMethod);
              debMaker.setSignRole(signRole);
              debMaker.setResolver(resolver);
              debMaker.setOpenReplaceToken(openReplaceToken);
              debMaker.setCloseReplaceToken(closeReplaceToken);
              debMaker.setDigest(digest);
              debMaker.setTarBigNumberMode(tarBigNumberMode);
              debMaker.setTarLongFileMode(tarLongFileMode);
              debMaker.validate();
              debMaker.makeDeb();
  
              // Always attach unless explicitly set to false
              if ("true".equalsIgnoreCase(attach)) {
                  console.info("Attaching created debian package " + debFile);
                  if (!isType()) {
                      projectHelper.attachArtifact(project, type, classifier, debFile);
                  } else {
                      project.getArtifact().setFile(debFile);
                  }
              }
  
          } catch (PackagingException e) {
              getLog().error("Failed to create debian package " + debFile, e);
              throw new MojoExecutionException("Failed to create debian package " + debFile, e);
          }
  
          if (!isBlank(propertyPrefix)) {
            project.getProperties().put(propertyPrefix+"version", getProjectVersion() );
            project.getProperties().put(propertyPrefix+"deb", debFile.getAbsolutePath());
            project.getProperties().put(propertyPrefix+"deb.name", debFile.getName());
            project.getProperties().put(propertyPrefix+"changes", changesOutFile.getAbsolutePath());
            project.getProperties().put(propertyPrefix+"changes.name", changesOutFile.getName());
            project.getProperties().put(propertyPrefix+"changes.txt", changesSaveFile.getAbsolutePath());
            project.getProperties().put(propertyPrefix+"changes.txt.name", changesSaveFile.getName());
          }
  
      }