Merge ~weichenwu/bugit:file-issue-to-JIRA into bugit:master

[Weichen Wu]

Provide an option to file an issue on JIRA

Note:
By default, the issue will go to Launchpad as we still mainly use Launchpad at the moment.

[StanleyHuang (stanley31)]

@Weichen,

I would suggest we modify the way to initial Jira/LaunchpadAssistant, please see my inline comment.

[StanleyHuang (stanley31)]

review: Needs Information

[HanhsuanLee (hanhsuan)]

Please see my inline comment

[HanhsuanLee (hanhsuan)]

LGTM + 1

review: Approve

[StanleyHuang (stanley31)]

LGTM

review: Approve

diff --git a/README.md b/README.md
index d6332a2..9ceaf40 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ $ snap install bugit --devmode
 
 
 Usage
------
+------------
 
 $ sudo bugit
 
@@ -26,9 +26,24 @@ You will be presented with a text user interface (TUI) to fill the important
 information (bug title, description, status, etc.).
 
 You can navigate between the different fields using the `up` and `down` keys
-and press `Alt+Enter` to submit the issue. It will be created on Launchpad, and
-logs will be gathered (using reporting tool `sosreport`) and attached to the
-report.
+and press `Alt+Enter` to submit the issue. All logs will be gathered 
+(using reporting tool `sosreport`) and attached to the report.
+
+By default, the issue will be created on Launchpad. 
+If you wish to create issue on JIRA, use:
+
+$ sudo bugit --jira
+
+Note: for issus to jira, the assignee could be entered partial unitl it has only one match
+For example, user email is [e-mail]
+You can enter "wei", it will output
+"""
[e-mail]
[e-mail]
[e-mail]
+"""
+
+By entering "weichen", it will only match the first one hence successfully assigned
 
 If you want to submit your issue to the Staging instance of Launchpad, use:
 
@@ -48,3 +63,10 @@ $ sudo bugit -p checkbox-ng -t "ce-qa-concern audio hdmi"
 If you want to reopen an issue, use:
 
 $ sudo bugit -p checkbox-ng -r 2000334
+
+
+Reference
+------------
+1. How to access a file in /var/lib
+Refer to this topic for details
+https://forum.snapcraft.io/t/read-access-to-a-file-in-var-lib-on-the-host/11766
\ No newline at end of file
diff --git a/bugit/__init__.py b/bugit/__init__.py
index cd4d8eb..40d77fc 100644
--- a/bugit/__init__.py
+++ b/bugit/__init__.py
@@ -3,10 +3,11 @@ import logging
 import os
 import sys
 
-from bugit.bug_assistant import BugAssistant, BugReport
+from bugit.bug_assistant import BugReport
 from bugit.ui import (
     JobsScreen, SessionsScreen, ReportScreen, ReopenReportScreen
 )
+
 import bugit.utils
 import bugit.checkbox_utils
 
@@ -16,7 +17,8 @@ logger = logging.getLogger(__name__)
 
 def main():
     if os.geteuid() != 0:
-        sys.exit("This tool MUST be run as super user. Please run `sudo bugit`.")
+        sys.exit("This tool MUST be run as super user. \
+            Please run `sudo bugit`.")
     snap_name = os.getenv("SNAP_NAME")
 
     if not snap_name:
@@ -42,7 +44,9 @@ def main():
     numeric_level = getattr(logging, loglevel.upper(), None)
     if not isinstance(numeric_level, int):
         raise ValueError("Invalid log level: {}".format(loglevel))
-    logging.basicConfig(filename=logfile, format=logformat, level=numeric_level)
+    logging.basicConfig(filename=logfile,
+                        format=logformat,
+                        level=numeric_level)
 
     epilog = (
         "Examples: `bugit --fwts -p somerville -t platform-tag-3` will "
@@ -55,10 +59,12 @@ def main():
     parser = argparse.ArgumentParser(epilog=epilog, argument_default="")
     parser.add_argument(
         "--fwts",
-        help=("Automatically files an issue in " "Launchpad for the firmware team"),
+        help=("Automatically files an issue in "
+              "Launchpad for the firmware team"),
         action="store_true",
     )
-    parser.add_argument("-a", "--assignee", help="Assignee e.g. your Launchpad ID")
+    parser.add_argument("-a", "--assignee",
+                        help="Assignee e.g. Launchpad ID or Jira account name")
     parser.add_argument("-p", "--project", help="Project name")
     parser.add_argument("-s", "--series", help="Series e.g. focal")
     parser.add_argument(
@@ -72,6 +78,11 @@ def main():
         "-r", "--reopen", help="Bug number you want to reopen",
         type=str, default=""
     )
+    parser.add_argument(
+        "--jira",
+        help=("File bug to JIRA"),
+        action="store_true",
+    )
     args = parser.parse_args()
     if args.fwts:
         if not args.project:
@@ -84,15 +95,16 @@ def main():
             if not args.project:
                 sys.exit("You must specify a project name, e.g -p somerville")
 
-            if not args.reopen.isnumeric():
-                sys.exit("Invalid bug number format: {}".format(args.reopen))
+            # if not args.reopen.isnumeric():
+            #     sys.exit("Invalid bug number format: {}".format(args.reopen))
 
             start_reopen_ui(
-                verify_bug_information(args.reopen, args.project),
+                args.reopen,
                 args.project,
                 assignee=args.assignee,
                 sku=args.sku,
-                cid=args.cid
+                cid=args.cid,
+                template="Jira" if args.jira else "Launchpad"
             )
         else:
             start_ui(
@@ -102,10 +114,23 @@ def main():
                 tags=args.tags,
                 sku=args.sku,
                 cid=args.cid,
+                template="Jira" if args.jira else "Launchpad"
             )
 
 
-def start_ui(assignee="", project="", series="", tags="", sku="", cid=""):
+def get_target_ba(template):
+    """ Get target ba, launchpad or jira
+    """
+    target_cls_name = f"{template}BugAssistant"
+    mod = __import__('bugit.bug_assistant', fromlist=[target_cls_name])
+    target_cls = getattr(mod, target_cls_name)
+    ba = target_cls()
+
+    return ba
+
+
+def start_ui(assignee="", project="", series="",
+             tags="", sku="", cid="", template=""):
     tags += " {}".format(cid)
     tags = " ".join(tags.split())  # Remove unwanted spaces
     job_id = ""
@@ -115,7 +140,8 @@ def start_ui(assignee="", project="", series="", tags="", sku="", cid=""):
         session_screen = SessionsScreen(items=checkbox_sessions_dir)
         session_screen.run()
         if session_screen.selected_item != "None":
-            jobs = bugit.checkbox_utils.Session(path=session_screen.selected_item)
+            jobs = bugit.checkbox_utils.Session(
+                path=session_screen.selected_item)
             jobs_screen = JobsScreen(items=jobs.get_run_jobs())
             jobs_screen.run()
             if jobs_screen.selected_item != "None":
@@ -124,16 +150,18 @@ def start_ui(assignee="", project="", series="", tags="", sku="", cid=""):
 
     report_screen = ReportScreen(
         assignee=assignee.lower(),
-        project=project.lower(),
+        project=project,
         series=series.lower(),
         tags=tags.lower(),
         sku=sku.strip().upper(),
         cid=cid,
         job_id=job_id,
         job_output=job_output,
+        template=template.lower()
     )
     report_screen.run()
-    ba = BugAssistant()
+
+    ba = get_target_ba(template)
     ba.update(report_screen.report())
     while True:
         try:
@@ -147,34 +175,12 @@ def start_ui(assignee="", project="", series="", tags="", sku="", cid=""):
             break
 
 
-def verify_bug_information(bug_no, project):
-    ba = BugAssistant()
-    ba.launchpad_login()
-    try:
-        bug = ba.get_bug(bug_no)
-        bug_link = ba.get_bug_attribute(bug, "self_link")
-    except KeyError:
-        raise ValueError("Invalid bug number: {}".format(bug_no))
+def start_reopen_ui(bug_id, project, assignee="", sku="", cid="", template=""):
 
-    project_bugs = ba.get_project_bugs_by_title(
-        project, ba.get_bug_attribute(bug, "title")
-    )
-
-    for p_bug in project_bugs:
-        if ba.get_bug_attribute(p_bug, "bug_link") == bug_link:
-            ba.bug = bug
-            break
-
-    if ba.bug is None:
-        sys.exit("Bug not exists in {} project: {}".format(project, bug_no))
-
-    return ba
-
-
-def start_reopen_ui(ba, project, assignee="", sku="", cid=""):
-    # collect tags from original bug
-    bug_info = ba.get_bug_infomation()
-    tags = "{} {}".format(bug_info["tags"], cid).strip()
+    ba = get_target_ba(template)
+    bug, bug_info = ba.bug_helper.get_bug_information(bug_id)
+    tags = "{} {}".format(bug_info["tags"], cid).strip() \
+        if template == "launchpad" else ""
 
     job_id = ""
     job_output = None
@@ -183,7 +189,8 @@ def start_reopen_ui(ba, project, assignee="", sku="", cid=""):
         session_screen = SessionsScreen(items=checkbox_sessions_dir)
         session_screen.run()
         if session_screen.selected_item != "None":
-            jobs = bugit.checkbox_utils.Session(path=session_screen.selected_item)
+            jobs = bugit.checkbox_utils.Session(
+                path=session_screen.selected_item)
             jobs_screen = JobsScreen(items=jobs.get_run_jobs())
             jobs_screen.run()
             if jobs_screen.selected_item != "None":
@@ -192,16 +199,18 @@ def start_reopen_ui(ba, project, assignee="", sku="", cid=""):
 
     report_screen = ReopenReportScreen(
         assignee=assignee.lower() or bug_info["assignee"],
-        project=project.lower(),
+        project=project,
         sku=sku.strip().upper(),
         cid=cid,
         title=bug_info["title"],
         tags=tags,
         importance=bug_info["importance"],
         job_id=job_id,
-        job_output=job_output
+        job_output=job_output,
+        template=template.lower()
     )
     report_screen.run()
+
     ba.update(report_screen.report())
     while True:
         try:
@@ -215,7 +224,7 @@ def start_reopen_ui(ba, project, assignee="", sku="", cid=""):
             break
 
 
-def auto_submit_fwts_report(project, tags):
+def auto_submit_fwts_report(project, tags, template=""):
     """
     Automatically file a Launchpad issue with log files needed by FWTS team
     without starting the UI.
@@ -233,7 +242,8 @@ def auto_submit_fwts_report(project, tags):
         importance="Critical",
         options=options,
     )
-    ba = BugAssistant(report)
+
+    ba = get_target_ba(template)
     try:
         result = ba.file_bug()
     except Exception as exc:
diff --git a/bugit/bug_assistant.py b/bugit/bug_assistant.py
index da778b1..4592fb0 100644
--- a/bugit/bug_assistant.py
+++ b/bugit/bug_assistant.py
@@ -1,15 +1,16 @@
-import getpass
 import os
 import re
 import subprocess
 import sys
 import tarfile
+import io
 from collections import Counter
 from glob import glob
-from launchpadlib.launchpad import Launchpad
-from launchpadlib.uris import LPNET_WEB_ROOT, STAGING_WEB_ROOT, QASTAGING_WEB_ROOT
 
-import bugit.checkbox_utils
+from bugit.helper.launchpad_helper import LaunchpadAssistant
+from bugit.helper.jira_helper import JiraAssistant
+
+from bugit.checkbox_utils import get_checkbox_last_session_dir
 import bugit.utils
 
 
@@ -68,220 +69,157 @@ class BugReport:
         self.options = options
 
 
-class BugAssistant:
-    """Handle a bug report, its attachments and their transmission to Launchpad."""
+class LaunchpadBugAssistant:
+    """Handle a bug report, its attachments and their transmission
+    to Launchpad.
+    """
 
     def __init__(self):
-        #self.update(bug_report)
-        # Launchpad bug, in case something is wrong after creating the bug
         self.bug = None
-        self.launchpad = None
+        self.bug_helper = LaunchpadAssistant()
 
     def update(self, bug_report):
-        self.lp_title = bug_report.title
-        self.lp_description = bug_report.description
-        self.lp_project = bug_report.project
-        self.lp_series = bug_report.series
-        self.lp_assignee = bug_report.assignee
-        self.lp_tags = bug_report.tags
-        self.lp_status = bug_report.status
-        self.lp_importance = bug_report.importance
+        self.title = bug_report.title
+        self.description = bug_report.description
+        self.project = bug_report.project
+        self.series = bug_report.series
+        self.assignee = bug_report.assignee
+        self.tags = bug_report.tags
+        self.status = bug_report.status
+        self.importance = bug_report.importance
         self.options = bug_report.options
 
-    def launchpad_login(self):
-        """Log in Launchpad and create credentials file if needed."""
-        # can be 'production', 'staging' or 'qastaging'
-        service_root = os.environ.get("APPORT_LAUNCHPAD_INSTANCE", "production")
-        print("Using {} service root".format(service_root))
-
-        directory = os.path.expanduser("~/.launchpadlib")
-        if not os.path.isdir(directory):
-            os.mkdir(directory)
-
-        launchpad = Launchpad.login_with(
-            "bugit",
-            service_root,
-            credentials_file=os.path.join(directory, "bugit"),
-            allow_access_levels=["WRITE_PRIVATE"],
-        )
-
-        # Small trick to force access to launchpad and verify authentication
-        launchpad.me
-        self.launchpad = launchpad
-
-    def get_bug_infomation(self):
-        if self.bug is None:
-            raise BugAssistantError("Bug is not defined")
-
-        bug_task = self.bug.bug_tasks[0]
-        bug_info = {
-            "status": bug_task.status,
-            "title": bug_task.title,
-            "tags": " ".join(self.bug.lp_get_parameter("tags")),
-            "assignee": bug_task.assignee.name if bug_task.assignee else "",
-            "importance": bug_task.importance
-        }
-
-        return bug_info
-
     def file_bug(self):
         """Upload bug report and its attachments to Launchpad."""
 
-        if not self.lp_title:
+        if not self.title:
             raise BugAssistantError("Bug title is mandatory")
-        if not self.lp_description:
+        if not self.description:
             raise BugAssistantError("Description is mandatory")
-        if not self.lp_project:
+        if not self.project:
             raise BugAssistantError("Project name is mandatory")
 
         print("Logging into Launchpad...")
-        self.launchpad_login()
-        launchpad = self.launchpad
+        launchpad = LaunchpadAssistant()
+        bug_dict = {
+            'assignee': self.assignee,
+            'project': self.project,
+            'title': self.title,
+            'description': self.description,
+            'priority': self.importance,
+            'status': self.status,
+            'tags': self.tags,
+            'series': self.series
+        }
+        self.bug, bug_url = launchpad.create_bug(bug_dict)
+        print("Uploading bug data...")
+        aa = AttachmentAssistant(self.options)
+        attachments = aa.run_attachment_methods()
+        launchpad.upload_attachments(attachments)
 
-        try:
-            print("Checking project name...")
-            project = launchpad.projects[self.lp_project]
-        except Exception:
-            error_message = "{} launchpad project not found".format(self.lp_project)
-            raise BugAssistantError(error_message)
-
-        series_name = self.lp_series
-        series = None
-        if series_name:
-            print("Checking series...")
-            series = project.getSeries(name=series_name)
-            if series is None:
-                error_message = "{} series not found".format(series_name)
-                raise BugAssistantError(error_message)
-
-        assignee_name = self.lp_assignee
-        assignee = None
-        if assignee_name:
-            try:
-                print("Checking assignee...")
-                assignee = launchpad.people[assignee_name]
-            except Exception:
-                error_message = "{} launchpad user not found".format(assignee_name)
-                raise BugAssistantError(error_message)
-
-        if not self.bug:
-            print("Creating Launchpad bug report...")
-            self.bug = launchpad.bugs.createBug(
-                title=self.lp_title,
-                description=self.lp_description,
-                tags=self.lp_tags.split(),
-                target=project,
-            )
-            print("Bug report #{} created.".format(self.bug.id))
-        else:
-            print("Updating Launchpad bug report...")
-            self.bug.title = self.lp_title
-            self.bug.description = self.lp_description
-            self.bug.tags = self.lp_tags.split()
-            self.bug.lp_save()
-
-        # Task configuration
-        task = self.bug.bug_tasks[0]
-        if self.bug and task.target != project:
-            print("Updating project...")
-            task.target = project
-            task.lp_save()
-
-        if series:
-            print("Setting series...")
-            nomination = self.bug.addNomination(target=series)
-            nomination.approve()
-
-        # We update bug info only for the latest created series
-        task = self.bug.bug_tasks[len(self.bug.bug_tasks) - 1]
-        if assignee:
-            print("Setting assignee for series {}...".format(task.bug_target_name))
-            task.assignee = assignee
-        print("Setting status...")
-        task.status = self.lp_status
-        print("Setting importance...")
-        task.importance = self.lp_importance
-
-        task.lp_save()
-
-        service_root = os.environ.get("APPORT_LAUNCHPAD_INSTANCE", "production")
-        if service_root == "qastaging":
-            bug_url = QASTAGING_WEB_ROOT + "bugs/{}".format(self.bug.id)
-        elif service_root == "staging":
-            bug_url = STAGING_WEB_ROOT + "bugs/{}".format(self.bug.id)
-        else:
-            bug_url = LPNET_WEB_ROOT + "bugs/{}".format(self.bug.id)
+        result = "Bug report #{} and its attachments are available at <{}>"
+        return result.format(self.bug.id, bug_url)
 
-        print("Bug report #{} updated.".format(self.bug.id))
+    def reopen(self):
+        """ Reopen a bug on launchpad
 
-        print("Uploading bug data...")
+        Args:
+            launchpad: launchpadAssistant instance
+        """
+        bug_dict = {
+            'assignee': self.assignee,
+            'project': self.project,
+            'title': self.title,
+            'description': self.description,
+            'priority': self.importance,
+            'status': self.status,
+            'tags': self.tags,
+            'series': self.series
+        }
+        launchpad = self.bug_helper
+        # add comment and update assignee/status/importance/tags
+        launchpad.add_comment(bug_dict['description'])
+        self.bug, bug_url = launchpad.update_bug(bug_dict)
+
+        # upload attachment
         aa = AttachmentAssistant(self.options)
-        aa.run_attachment_methods()
-        aa.upload_attachments(launchpad, self.bug.id)
+        attachments = aa.run_attachment_methods()
+        launchpad.upload_attachments(attachments)
 
         result = "Bug report #{} and its attachments are available at <{}>"
         return result.format(self.bug.id, bug_url)
 
-    def reopen(self):
-        assignee_name = self.lp_assignee
-        assignee = None
-        if assignee_name:
-            try:
-                print("Checking assignee...")
-                assignee = self.launchpad.people[assignee_name]
-            except Exception:
-                error_message = "{} launchpad user not found".format(
-                                                            assignee_name)
-                raise BugAssistantError(error_message)
-
-        bug_task = self.bug.bug_tasks[0]
-        self.add_comment(self.lp_description)
-        if assignee:
-            print("Setting assignee to {}...".format(bug_task.assignee))
-            bug_task.assignee = assignee
-        print("Setting status...")
-        bug_task.status = self.lp_status
-        print("Setting importance...")
-        bug_task.importance = self.lp_importance
-
-        bug_task.lp_save()
-
-        self.bug.tags = self.lp_tags.split()
-        self.bug.lp_save()
-
-        service_root = os.environ.get("APPORT_LAUNCHPAD_INSTANCE", "production")
-        if service_root == "qastaging":
-            bug_url = QASTAGING_WEB_ROOT + "bugs/{}".format(self.bug.id)
-        elif service_root == "staging":
-            bug_url = STAGING_WEB_ROOT + "bugs/{}".format(self.bug.id)
-        else:
-            bug_url = LPNET_WEB_ROOT + "bugs/{}".format(self.bug.id)
 
-        print("Bug report #{} updated.".format(self.bug.id))
+class JiraBugAssistant:
+    def __init__(self):
+        self.bug = None
+        self.bug_helper = JiraAssistant()
+
+    def update(self, bug_report):
+        self.title = bug_report.title
+        self.description = bug_report.description
+        self.project = bug_report.project
+        self.assignee = bug_report.assignee
+        self.tags = bug_report.tags
+        self.status = bug_report.status
+        self.importance = bug_report.importance
+        self.options = bug_report.options
+
+    def file_bug(self):
+        """Upload bug report and its attachments to JIRA."""
+
+        if not self.title:
+            raise BugAssistantError("Bug title is mandatory")
+        if not self.description:
+            raise BugAssistantError("Description is mandatory")
+        if not self.project:
+            raise BugAssistantError("Project name is mandatory")
 
+        print("Logging into Jira...")
+        jira = JiraAssistant()
+        bug_dict = {
+            'assignee': self.assignee,
+            'project': self.project,
+            'summary': self.title,
+            'description': self.description,
+            'priority': {'name': self.importance},
+            'issuetype': {'name': 'Bug'}
+        }
+        self.bug, bug_url = jira.create_bug(bug_dict)
         print("Uploading bug data...")
         aa = AttachmentAssistant(self.options)
-        aa.run_attachment_methods()
-        aa.upload_attachments(self.launchpad, self.bug.id)
+        attachments = aa.run_attachment_methods()
+        jira.upload_attachments(attachments)
 
         result = "Bug report #{} and its attachments are available at <{}>"
-        return result.format(self.bug.id, bug_url)
+        return result.format(self.bug.key, bug_url)
 
-    def add_comment(self, data):
-        self.bug.newMessage(content=data)
+    def reopen(self):
+        """ Reopen a bug on Jira
 
-    def get_bug(self, bug_id):
-        return self.launchpad.bugs[bug_id]
+        Args:
+            jira: JiraAssistant instance
+        """
 
-    def get_project_bugs_by_title(self, project, title):
-        lp_project = self.launchpad.projects[project]
-        project_bugs = lp_project.searchTasks(
-            search_text=title
-        )
-        return project_bugs
+        bug_dict = {
+            'assignee': self.assignee,
+            'project': self.project,
+            'summary': self.title,
+            'description': self.description,
+            'priority': {'name': self.importance}
+        }
+        jira = self.bug_helper
+        # add comment and update assignee/importance
+        jira.add_comment(bug_dict['description'])
+        self.bug, bug_url = jira.update_bug(bug_dict)
+
+        # upload attachment
+        aa = AttachmentAssistant(self.options)
+        attachments = aa.run_attachment_methods()
+        jira.upload_attachments(attachments)
 
-    def get_bug_attribute(self, bug, attr):
-        return bug.lp_get_parameter(attr)
+        result = "Bug report #{} and its attachments are available at <{}>"
+        return result.format(self.bug.key, bug_url)
 
 
 class BugAssistantError(Exception):
@@ -302,15 +240,6 @@ class AttachmentAssistant:
         self.attachments = {}
         self.options = options
 
-    def upload_attachments(self, lp_instance, bug_number):
-        attachments = self.attachments
-        for a in attachments:
-            print("Uploading attachment {}...".format(a))
-            bug = lp_instance.bugs[bug_number]
-            bug.addAttachment(
-                comment="Automatically attached", filename=a, data=attachments[a]
-            )
-
     def run_attachment_methods(self):
         """Runs the different attachment methods to add logs to the
         attachments dictionary."""
@@ -326,6 +255,8 @@ class AttachmentAssistant:
         if self.options.get("collect_log"):
             self.attach_log_report()
 
+        return self.attachments
+
     def attach_log_report(self):
         home_dir = os.getenv("HOME")
         print("Running log report...")
@@ -337,7 +268,7 @@ class AttachmentAssistant:
             with open(report_name, mode="rb") as f:
                 data = f.read()
                 self.attachments[report_name] = data
-        except subprocess.CalledProcessError as e:
+        except subprocess.CalledProcessError:
             print("Failed to collect log by oem-getlogs, try sosreport...")
             try:
                 command = [
@@ -385,11 +316,13 @@ class AttachmentAssistant:
                 devmode,
                 snap.props.confinement.value_nick,
             )
-        self.attachments["snap_list.log"] = out.encode()
+        # Note: jiralib's add_attachment can only handle file-like object
+        data = io.BytesIO(out.encode())
+        self.attachments["snap_list.log"] = data.read()
 
     def attach_last_checkbox_session(self):
         """Archive and attach the most recent Checkbox session available."""
-        latest_session_dir = bugit.checkbox_utils.get_checkbox_last_session_dir()
+        latest_session_dir = get_checkbox_last_session_dir()
         if latest_session_dir:
             session_tgz = os.path.expandvars("$HOME/checkbox-session.tgz")
             if os.path.exists(session_tgz):
@@ -405,9 +338,10 @@ class AttachmentAssistant:
         and attach them.
         """
 
-        latest_session_dir = bugit.checkbox_utils.get_checkbox_last_session_dir()
+        latest_session_dir = get_checkbox_last_session_dir()
         if latest_session_dir:
-            logpath = os.path.join(latest_session_dir, "CHECKBOX_DATA", "fwts*.log")
+            logpath = os.path.join(
+                latest_session_dir, "CHECKBOX_DATA", "fwts*.log")
             logfiles = glob(logpath)
             if logfiles:
                 for log in logfiles:
@@ -417,7 +351,8 @@ class AttachmentAssistant:
             else:
                 print("No FWTS logs found in Checkbox session!")
         else:
-            print(("Cannot find Checkbox session where FWTS logs could be " "located!"))
+            print("Cannot find Checkbox session where"
+                  "FWTS logs could be located!")
 
     def attach_nvidia_bug_report(self):
 
@@ -445,14 +380,10 @@ class AttachmentAssistant:
     def attach_acpidump(self):
         print("Running acpidump...")
         command = ["acpidump"]
-        process = subprocess.run(
-            command, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-        if process.returncode == 0:
-            self.attachments["acpidump.log"] = process.stdout
-        else:
-            print("Error while running acpidump:")
-            print(process.stderr)
+        acpi_output = issue_commands(command)
+        if acpi_output is not None:
+            data = io.BytesIO(acpi_output.encode())
+            self.attachments["acpidump.log"] = data.read()
 
     def attach_previous_kernel_log(self):
         print("Dumping previous kernel log...")
@@ -486,8 +417,8 @@ class AttachmentAssistant:
         standard_info = {}
 
         buildstamp_paths = [
-            # For how to access a file in /var/lib
-            # See: https://forum.snapcraft.io/t/read-access-to-a-file-in-var-lib-on-the-host/11766
+            # For how to access a file in /var/lib,
+            # please find reference in README
             "/var/lib/snapd/hostfs/var/lib/ubuntu_dist_channel",  # PC project
             "/var/lib/snapd/hostfs/.disk/info",  # ubuntu classic
             "/run/mnt/ubuntu-seed/.disk/info",  # ubuntu core
@@ -578,7 +509,8 @@ class AttachmentAssistant:
                 cpu_names[cpu_name] += 1
 
         cpu_names_str = [
-            "{} ({}x)".format(cpu_name, count) for cpu_name, count in cpu_names.items()
+            "{} ({}x)".format(cpu_name, count)
+            for cpu_name, count in cpu_names.items()
         ]
 
         return "\n".join(cpu_names_str)
diff --git a/bugit/helper/jira_helper.py b/bugit/helper/jira_helper.py
new file mode 100644
index 0000000..1ce6045
--- /dev/null
+++ b/bugit/helper/jira_helper.py
@@ -0,0 +1,151 @@
+#!/usr/bin/python3
+
+import os
+import configparser
+
+from jira import JIRA
+
+JIRA_SERVER = "https://warthogs.atlassian.net/"
+JIRA_CONFIG_DIR = "{}/.jira.conf".format(os.path.expanduser('~'))
+
+
+class JiraAssistant():
+
+    def __init__(self, server=JIRA_SERVER, config_dir=JIRA_CONFIG_DIR):
+        self.server = server
+        self.config_dir = config_dir
+
+        config = configparser.ConfigParser()
+        while not config.read(self.config_dir):
+            self.create_token()
+        jiracfg = config["jira"]
+        self.user = jiracfg["user"]
+        self.token = jiracfg["token"]
+
+        self.jira = JIRA(server=self.server,
+                         basic_auth=(self.user, self.token))
+        self.bug = None
+
+    def create_token(self):
+        """ Create token file to store user's email and token
+        """
+        email = input("Enter the user's email: ")
+        token = input(
+            "Enter the user's token (see "
+            "https://id.atlassian.com/manage-profile/security/api-tokens): "
+        )
+
+        config = configparser.ConfigParser()
+        config.add_section("jira")
+        jiracfg = config["jira"]
+        jiracfg["user"] = email
+        jiracfg["token"] = token
+        with open(self.config_dir, 'w') as configfile:
+            config.write(configfile)
+
+    def get_bug_information(self, bug_id):
+        """ Get bug's informations by given bug ID
+        """
+        try:
+            print("Checking bug...")
+            self.bug = self.jira.issue(id=bug_id)
+        except Exception:
+            error_msg = f"{bug_id} jira bug not found"
+            raise JIRAAssistantError(error_msg)
+
+        bug_info = {
+            "title": self.bug.raw['fields']['summary'],
+            "importance": self.bug.raw['fields']['priority']['name'],
+            "assignee": self.bug.raw['fields']['assignee']['displayName']
+        }
+
+        return self.bug, bug_info
+
+    def check_assignee(self, assignee):
+        """ Check if the given assignee is exist
+        """
+        users = self.jira.search_users(query=assignee)
+        if len(users) > 1:
+            error_msg = "There are more than 1 matched users," \
+                "please give an unique username"
+            for user in users:
+                error_msg += f"{user.emailAddress}\n"
+            raise JIRAAssistantError(error_msg)
+
+        elif len(users) == 0:
+            error_msg = "There is no matched user," \
+                "please give an unique username"
+            raise JIRAAssistantError(error_msg)
+
+        return users[0].emailAddress
+
+    def check_project(self, project_name):
+        """ Check if the given project key is exist
+        """
+        try:
+            project = self.jira.project(id=project_name)
+        except Exception:
+            error_msg = f"Project {project_name} not found on JIRA"
+            raise JIRAAssistantError(error_msg)
+
+        return project.key
+
+    def create_bug(self, bug_dict):
+        """ Create bug to JIRA
+        """
+        if bug_dict['assignee']:
+            print("check assignee...")
+            assignee_id = self.check_assignee(bug_dict['assignee'])
+
+        if bug_dict['project']:
+            print("check project...")
+            project_key = self.check_project(bug_dict['project'])
+
+        print(f"Creating issue to {project_key}...")
+        self.bug = self.jira.create_issue(bug_dict)
+        bug_url = f"https://warthogs.atlassian.net/browse/{self.bug.key}"
+        print(f"Issue {self.bug.key} is created")
+
+        # Assign the ticket to given assignee
+        self.jira.assign_issue(self.bug.key, assignee_id)
+
+        return self.bug, bug_url
+
+    def upload_attachments(self, attachments):
+        """ Upload an attachment to a ticket
+        """
+        for a in attachments:
+            print("Uploading attachment {}...".format(a))
+            self.jira.add_attachment(self.bug.id,
+                                     filename=a,
+                                     attachment=attachments[a])
+
+    def add_comment(self, comment):
+        """Add comment to the bug
+        """
+        print("Adding comment...")
+        update_dict = {'comment': [{'add': {'body': comment}}]}
+        self.bug.update(update=update_dict)
+
+    def update_bug(self, bug_dict):
+        """Update bug informations
+        """
+
+        if bug_dict['assignee']:
+            print("check assignee...")
+            assignee_id = self.check_assignee(bug_dict['assignee'])
+            self.jira.assign_issue(self.bug.key, assignee_id)
+
+        update_dict = {"priority": bug_dict['priority']}
+        self.bug.update(fields=update_dict)
+
+        bug_url = f"https://warthogs.atlassian.net/browse/{self.bug.key}"
+        print(f"Issue {self.bug.key} is updated")
+
+        return self.bug, bug_url
+
+
+class JIRAAssistantError(Exception):
+    """Raised when an error is reported during upload to JIRA."""
+
+    pass
diff --git a/bugit/helper/launchpad_helper.py b/bugit/helper/launchpad_helper.py
new file mode 100644
index 0000000..90ca6fc
--- /dev/null
+++ b/bugit/helper/launchpad_helper.py
@@ -0,0 +1,234 @@
+import os
+from launchpadlib.launchpad import Launchpad
+from launchpadlib.uris import LPNET_WEB_ROOT, STAGING_WEB_ROOT, \
+    QASTAGING_WEB_ROOT
+
+
+class LaunchpadAssistant():
+    def __init__(self):
+        # can be 'production', 'staging' or 'qastaging'
+        service_root = os.environ.get(
+            "APPORT_LAUNCHPAD_INSTANCE", "production")
+        print("Using {} service root".format(service_root))
+
+        directory = os.path.expanduser("~/.launchpadlib")
+        if not os.path.isdir(directory):
+            os.mkdir(directory)
+
+        launchpad = Launchpad.login_with(
+            "bugit",
+            service_root,
+            credentials_file=os.path.join(directory, "bugit"),
+            allow_access_levels=["WRITE_PRIVATE"],
+        )
+
+        # Small trick to force access to launchpad and verify authentication
+        launchpad.me
+        self.launchpad = launchpad
+        self.bug = None
+
+    def get_bug_information(self, bug_id):
+        """ Get existing bug's informations from launchpad
+
+        Args:
+            bug_id (string): bug ID to retrive from launchpad
+        """
+
+        try:
+            print("Checking bug...")
+            self.bug = self.launchpad.bugs[bug_id]
+        except Exception:
+            error_message = "{} launchpad bug not found".format(bug_id)
+            raise LaunchpadAssistantError(error_message)
+
+        bug_task = self.bug.bug_tasks[0]
+        bug_info = {
+            "status": bug_task.status,
+            "title": bug_task.title,
+            "tags": " ".join(self.bug.lp_get_parameter("tags")),
+            "assignee": bug_task.assignee.name if bug_task.assignee else "",
+            "importance": bug_task.importance
+        }
+
+        return self.bug, bug_info
+
+    def check_project_exist(self, project_name):
+        """ Check if given project name exist
+        """
+
+        try:
+            print("Checking project name...")
+            project = self.launchpad.projects[project_name]
+        except Exception:
+            error_message = "{} launchpad project not found".format(
+                project_name)
+            raise LaunchpadAssistantError(error_message)
+
+        return project
+
+    def check_series_exist(self, project, series_name):
+        """ Check if given series name exist in the project
+        """
+
+        print("Checking series...")
+        series = project.getSeries(name=series_name)
+        if series is None:
+            error_message = "{} series not found".format(series_name)
+            raise LaunchpadAssistantError(error_message)
+
+        return series
+
+    def check_assignee_exist(self, assignee_name):
+        """ Check if given assignee exist
+        """
+
+        try:
+            print("Checking assignee...")
+            assignee = self.launchpad.people[assignee_name]
+        except Exception:
+            error_message = "{} launchpad user not found".format(assignee_name)
+            raise LaunchpadAssistantError(error_message)
+
+        return assignee
+
+    def create_bug(self, bug_dict):
+        """Create issue to Launchpad with given informations
+
+        Args:
+            bug_dict (dict): Contain all information needed to creating a bug
+
+        """
+        # checking if the project is exist
+        lp_project = None
+        lp_project = self.check_project_exist(bug_dict['project'])
+
+        # checking if the series is exist
+        lp_series = None
+        if bug_dict['series']:
+            lp_series = self.check_series_exist(lp_project, bug_dict['series'])
+
+        # checking if assignee is exist
+        lp_assignee = None
+        if bug_dict['assignee']:
+            lp_assignee = self.check_assignee_exist(bug_dict['assignee'])
+
+        if not self.bug:
+            print("Creating Launchpad bug report...")
+            self.bug = self.launchpad.bugs.createBug(
+                title=bug_dict['title'],
+                description=bug_dict['description'],
+                tags=bug_dict['tags'].split(),
+                target=lp_project
+            )
+            print("Bug report #{} created.".format(self.bug.id))
+        else:
+            print("Updating Launchpad bug report...")
+            self.bug.title = self.lp_title
+            self.bug.description = self.lp_description
+            self.bug.tags = self.lp_tags.split()
+            self.bug.lp_save()
+
+        # Task configuration
+        task = self.bug.bug_tasks[0]
+        if self.bug and task.target != lp_project:
+            print("Updating project...")
+            task.target = lp_project
+            task.lp_save()
+
+        if lp_series:
+            print("Setting series...")
+            nomination = self.bug.addNomination(target=lp_series)
+            nomination.approve()
+
+        # We update bug info only for the latest created series
+        task = self.bug.bug_tasks[len(self.bug.bug_tasks) - 1]
+        if lp_assignee:
+            print(f"Setting assignee for series {task.bug_target_name}...")
+            task.assignee = lp_assignee
+        print("Setting status...")
+        task.status = bug_dict['status']
+        print("Setting importance...")
+        task.importance = bug_dict['priority']
+
+        task.lp_save()
+
+        service_root = os.environ.get(
+            "APPORT_LAUNCHPAD_INSTANCE", "production")
+        if service_root == "qastaging":
+            bug_url = QASTAGING_WEB_ROOT + f"bugs/{self.bug.id}"
+        elif service_root == "staging":
+            bug_url = STAGING_WEB_ROOT + f"bugs/{self.bug.id}"
+        else:
+            bug_url = LPNET_WEB_ROOT + f"bugs/{self.bug.id}"
+
+        print("Bug report #{} updated.".format(self.bug.id))
+        print(bug_url)
+
+        return self.bug, bug_url
+
+    def upload_attachments(self, attachments):
+        """Upload attachments to the issue
+
+        Args:
+            attachments (list): List of attachments
+        """
+
+        for a in attachments:
+            print("Uploading attachment {}...".format(a))
+            # bug = self.launchpad.bugs[bug_id]
+            self.bug.addAttachment(
+                comment="Automatically attached",
+                filename=a,
+                data=attachments[a]
+            )
+
+    def add_comment(self, comment):
+        """Add comment to the bug
+        """
+
+        print("Adding comment...")
+        self.bug.newMessage(content=comment)
+
+    def update_bug(self, bug_dict):
+        """Upload bug informations
+        """
+
+        bug_task = self.bug.bug_tasks[0]
+
+        lp_assignee = None
+        if bug_dict['assignee']:
+            lp_assignee = self.check_assignee_exist(bug_dict['assignee'])
+            print("Setting assignee to {}...".format(bug_dict['assignee']))
+            bug_task.assignee = lp_assignee
+
+        if bug_dict['status']:
+            print("Setting status to {}...".format(bug_dict['status']))
+            bug_task.status = bug_dict['status']
+        if bug_dict['priority']:
+            print("Setting priority to {}...".format(bug_dict['priority']))
+            bug_task.importance = bug_dict['priority']
+        if bug_dict['tags']:
+            print("Setting tag...")
+            self.bug.tags = bug_dict['tags'].split()
+
+        self.bug.lp_save()
+        bug_task.lp_save()
+
+        service_root = os.environ.get(
+            "APPORT_LAUNCHPAD_INSTANCE", "production")
+        if service_root == "qastaging":
+            bug_url = QASTAGING_WEB_ROOT + f"bugs/{self.bug.id}"
+        elif service_root == "staging":
+            bug_url = STAGING_WEB_ROOT + f"bugs/{self.bug.id}"
+        else:
+            bug_url = LPNET_WEB_ROOT + f"bugs/{self.bug.id}"
+
+        print("Bug report #{} updated.".format(self.bug.id))
+
+        return self.bug, bug_url
+
+
+class LaunchpadAssistantError(Exception):
+    """Raised when an error is reported during upload to Launchpad."""
+
+    pass
diff --git a/bugit/ui.py b/bugit/ui.py
index cdd0268..986621d 100644
--- a/bugit/ui.py
+++ b/bugit/ui.py
@@ -127,8 +127,10 @@ class ReportScreen:
     ]
 
     statuses = ("New", "Confirmed")
-    importances = ("Undecided", "Wishlist", "Low", "Medium", "High", "Critical")
-
+    importances = {
+        'launchpad': ("Undecided", "Wishlist", "Low", "Medium", "High", "Critical"),
+        'jira': ("Lowest", "Low", "Medium", "High", "Highest")
+    }
     STAGE_IMMEDIATE = "Issue reported and logs collected right after it happened"
     STAGE_FROZEN_DEVICE = (
         "Device froze, issue reported and logs collected right after a reboot"
@@ -162,6 +164,7 @@ class ReportScreen:
         cid="",
         job_id="",
         job_output=None,
+        template="Launchpad",
     ):
         if job_id and job_output:
             self.default_description += f"[Checkbox job `{job_id}` output]\n\n"
@@ -202,7 +205,7 @@ class ReportScreen:
         for s in self.statuses:
             rb = urwid.RadioButton(self._status, s, "first True", None)
         self._importance = []
-        for i in self.importances:
+        for i in self.importances[template]:
             rb = urwid.RadioButton(self._importance, i, "first True", None)
         self._stage_bug_filed = []
         for s in self.stage_bug_filed:
@@ -226,7 +229,7 @@ class ReportScreen:
             )
             self._bug_vendors.append(cb)
         self._assignee = urwid.LineBox(
-            urwid.Edit(edit_text=assignee), "Assigned To (Launchpad ID)"
+            urwid.Edit(edit_text=assignee), "Assigned To"
         )
         self._tags = urwid.LineBox(urwid.Edit(edit_text=tags), "Tags")
         status_list = urwid.LineBox(urwid.Pile(self._status), "Status")
@@ -377,6 +380,7 @@ class ReopenReportScreen(ReportScreen):
         importance="",
         job_id="",
         job_output=None,
+        template="Launchpad"
     ):
         if job_id and job_output:
             job_pattern = ["comments", "stdout", "stderr"]
@@ -417,7 +421,7 @@ class ReopenReportScreen(ReportScreen):
             self._status, self.statuses[1], "first True", None
         )
         self._importance = []
-        for i in self.importances:
+        for i in self.importances[template]:
             rb = urwid.RadioButton(self._importance, i, "first True", None)
         [rb.set_state(True) for rb in self._importance
                                 if rb.label == importance]