Beispiel #1
0
def process(section,
            dir_name,
            input_name=None,
            failed=False,
            client_agent='manual',
            download_id=None,
            input_category=None,
            failure_link=None):

    cfg = dict(core.CFG[section][input_category])

    host = cfg['host']
    port = cfg['port']
    ssl = int(cfg.get('ssl', 0))
    web_root = cfg.get('web_root', '')
    protocol = 'https://' if ssl else 'http://'
    username = cfg.get('username', '')
    password = cfg.get('password', '')
    apikey = cfg.get('apikey', '')

    if server_responding('{0}{1}:{2}{3}'.format(protocol, host, port,
                                                web_root)):
        # auto-detect correct fork
        fork, fork_params = auto_fork(section, input_category)
    elif not username and not apikey:
        logger.info(
            'No SickBeard username or Sonarr apikey entered. Performing transcoder functions only'
        )
        fork, fork_params = 'None', {}
    else:
        logger.error('Server did not respond. Exiting', section)
        return ProcessResult(
            status_code=1,
            message='{0}: Failed to post-process - {0} did not respond.'.
            format(section),
        )

    delete_failed = int(cfg.get('delete_failed', 0))
    nzb_extraction_by = cfg.get('nzbExtractionBy', 'Downloader')
    process_method = cfg.get('process_method')
    if client_agent == core.TORRENT_CLIENT_AGENT and core.USE_LINK == 'move-sym':
        process_method = 'symlink'
    remote_path = int(cfg.get('remote_path', 0))
    wait_for = int(cfg.get('wait_for', 2))
    force = int(cfg.get('force', 0))
    delete_on = int(cfg.get('delete_on', 0))
    ignore_subs = int(cfg.get('ignore_subs', 0))
    status = int(failed)
    if status > 0 and core.NOEXTRACTFAILED:
        extract = 0
    else:
        extract = int(cfg.get('extract', 0))
    # get importmode, default to 'Move' for consistency with legacy
    import_mode = cfg.get('importMode', 'Move')

    if not os.path.isdir(dir_name) and os.path.isfile(
            dir_name
    ):  # If the input directory is a file, assume single file download and split dir/name.
        dir_name = os.path.split(os.path.normpath(dir_name))[0]

    specific_path = os.path.join(dir_name, str(input_name))
    clean_name = os.path.splitext(specific_path)
    if clean_name[1] == '.nzb':
        specific_path = clean_name[0]
    if os.path.isdir(specific_path):
        dir_name = specific_path

    # Attempt to create the directory if it doesn't exist and ignore any
    # error stating that it already exists. This fixes a bug where SickRage
    # won't process the directory because it doesn't exist.
    if dir_name:
        try:
            os.makedirs(dir_name)  # Attempt to create the directory
        except OSError as e:
            # Re-raise the error if it wasn't about the directory not existing
            if e.errno != errno.EEXIST:
                raise

    if 'process_method' not in fork_params or (
            client_agent in ['nzbget', 'sabnzbd']
            and nzb_extraction_by != 'Destination'):
        if input_name:
            process_all_exceptions(input_name, dir_name)
            input_name, dir_name = convert_to_ascii(input_name, dir_name)

        # Now check if tv files exist in destination.
        if not list_media_files(
                dir_name, media=True, audio=False, meta=False, archives=False):
            if list_media_files(
                    dir_name, media=False, audio=False, meta=False,
                    archives=True) and extract:
                logger.debug(
                    'Checking for archives to extract in directory: {0}'.
                    format(dir_name))
                core.extract_files(dir_name)
                input_name, dir_name = convert_to_ascii(input_name, dir_name)

        if list_media_files(
                dir_name, media=True, audio=False, meta=False, archives=False
        ):  # Check that a video exists. if not, assume failed.
            flatten(dir_name)

    # Check video files for corruption
    good_files = 0
    num_files = 0
    for video in list_media_files(dir_name,
                                  media=True,
                                  audio=False,
                                  meta=False,
                                  archives=False):
        num_files += 1
        if transcoder.is_video_good(video, status):
            good_files += 1
            import_subs(video)
    if num_files > 0:
        if good_files == num_files and not status == 0:
            logger.info('Found Valid Videos. Setting status Success')
            status = 0
            failed = 0
        if good_files < num_files and status == 0:
            logger.info('Found corrupt videos. Setting status Failed')
            status = 1
            failed = 1
            if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][
                    0:5] >= '14.0':
                print('[NZB] MARK=BAD')
            if failure_link:
                failure_link += '&corrupt=true'
    elif client_agent == 'manual':
        logger.warning(
            'No media files found in directory {0} to manually process.'.
            format(dir_name), section)
        return ProcessResult(
            message='',
            status_code=0,  # Success (as far as this script is concerned)
        )
    elif nzb_extraction_by == 'Destination':
        logger.info(
            'Check for media files ignored because nzbExtractionBy is set to Destination.'
        )
        if int(failed) == 0:
            logger.info('Setting Status Success.')
            status = 0
            failed = 0
        else:
            logger.info(
                'Downloader reported an error during download or verification. Processing this as a failed download.'
            )
            status = 1
            failed = 1
    else:
        logger.warning(
            'No media files found in directory {0}. Processing this as a failed download'
            .format(dir_name), section)
        status = 1
        failed = 1
        if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][
                0:5] >= '14.0':
            print('[NZB] MARK=BAD')

    if status == 0 and core.TRANSCODE == 1:  # only transcode successful downloads
        result, new_dir_name = transcoder.transcode_directory(dir_name)
        if result == 0:
            logger.debug(
                'SUCCESS: Transcoding succeeded for files in {0}'.format(
                    dir_name), section)
            dir_name = new_dir_name

            chmod_directory = int(str(cfg.get('chmodDirectory', '0')), 8)
            logger.debug(
                'Config setting \'chmodDirectory\' currently set to {0}'.
                format(oct(chmod_directory)), section)
            if chmod_directory:
                logger.info(
                    'Attempting to set the octal permission of \'{0}\' on directory \'{1}\''
                    .format(oct(chmod_directory), dir_name), section)
                core.rchmod(dir_name, chmod_directory)
        else:
            logger.error(
                'FAILED: Transcoding failed for files in {0}'.format(dir_name),
                section)
            return ProcessResult(
                message='{0}: Failed to post-process - Transcoding failed'.
                format(section),
                status_code=1,
            )

    # configure SB params to pass
    fork_params['quiet'] = 1
    fork_params['proc_type'] = 'manual'
    if input_name is not None:
        fork_params['nzbName'] = input_name

    for param in copy.copy(fork_params):
        if param == 'failed':
            fork_params[param] = failed
            if 'proc_type' in fork_params:
                del fork_params['proc_type']
            if 'type' in fork_params:
                del fork_params['type']

        if param == 'return_data':
            fork_params[param] = 0
            if 'quiet' in fork_params:
                del fork_params['quiet']

        if param == 'type':
            fork_params[param] = 'manual'
            if 'proc_type' in fork_params:
                del fork_params['proc_type']

        if param in [
                'dir_name', 'dir', 'proc_dir', 'process_directory', 'path'
        ]:
            fork_params[param] = dir_name
            if remote_path:
                fork_params[param] = remote_dir(dir_name)

        if param == 'process_method':
            if process_method:
                fork_params[param] = process_method
            else:
                del fork_params[param]

        if param in ['force', 'force_replace']:
            if force:
                fork_params[param] = force
            else:
                del fork_params[param]

        if param in ['delete_on', 'delete']:
            if delete_on:
                fork_params[param] = delete_on
            else:
                del fork_params[param]

        if param == 'ignore_subs':
            if ignore_subs:
                fork_params[param] = ignore_subs
            else:
                del fork_params[param]

        if param == 'force_next':
            fork_params[param] = 1

    # delete any unused params so we don't pass them to SB by mistake
    [fork_params.pop(k) for k, v in list(fork_params.items()) if v is None]

    if status == 0:
        if section == 'NzbDrone' and not apikey:
            logger.info('No Sonarr apikey entered. Processing completed.')
            return ProcessResult(
                message='{0}: Successfully post-processed {1}'.format(
                    section, input_name),
                status_code=0,
            )
        logger.postprocess(
            'SUCCESS: The download succeeded, sending a post-process request',
            section)
    else:
        core.FAILED = True
        if failure_link:
            report_nzb(failure_link, client_agent)
        if 'failed' in fork_params:
            logger.postprocess(
                'FAILED: The download failed. Sending \'failed\' process request to {0} branch'
                .format(fork), section)
        elif section == 'NzbDrone':
            logger.postprocess(
                'FAILED: The download failed. Sending failed download to {0} for CDH processing'
                .format(fork), section)
            return ProcessResult(
                message='{0}: Download Failed. Sending back to {0}'.format(
                    section),
                status_code=
                1,  # Return as failed to flag this in the downloader.
            )
        else:
            logger.postprocess(
                'FAILED: The download failed. {0} branch does not handle failed downloads. Nothing to process'
                .format(fork), section)
            if delete_failed and os.path.isdir(
                    dir_name) and not os.path.dirname(dir_name) == dir_name:
                logger.postprocess(
                    'Deleting failed files and folder {0}'.format(dir_name),
                    section)
                remove_dir(dir_name)
            return ProcessResult(
                message=
                '{0}: Failed to post-process. {0} does not support failed downloads'
                .format(section),
                status_code=
                1,  # Return as failed to flag this in the downloader.
            )

    url = None
    if section == 'SickBeard':
        if apikey:
            url = '{0}{1}:{2}{3}/api/{4}/'.format(protocol, host, port,
                                                  web_root, apikey)
            if not 'cmd' in fork_params:
                if 'SickGear' in fork:
                    fork_params['cmd'] = 'sg.postprocess'
                else:
                    fork_params['cmd'] = 'postprocess'
        elif fork == 'Stheno':
            url = '{0}{1}:{2}{3}/home/postprocess/process_episode'.format(
                protocol, host, port, web_root)
        else:
            url = '{0}{1}:{2}{3}/home/postprocess/processEpisode'.format(
                protocol, host, port, web_root)
    elif section == 'NzbDrone':
        url = '{0}{1}:{2}{3}/api/command'.format(protocol, host, port,
                                                 web_root)
        url2 = '{0}{1}:{2}{3}/api/config/downloadClient'.format(
            protocol, host, port, web_root)
        headers = {'X-Api-Key': apikey}
        # params = {'sortKey': 'series.title', 'page': 1, 'pageSize': 1, 'sortDir': 'asc'}
        if remote_path:
            logger.debug('remote_path: {0}'.format(remote_dir(dir_name)),
                         section)
            data = {
                'name': 'DownloadedEpisodesScan',
                'path': remote_dir(dir_name),
                'downloadClientId': download_id,
                'importMode': import_mode
            }
        else:
            logger.debug('path: {0}'.format(dir_name), section)
            data = {
                'name': 'DownloadedEpisodesScan',
                'path': dir_name,
                'downloadClientId': download_id,
                'importMode': import_mode
            }
        if not download_id:
            data.pop('downloadClientId')
        data = json.dumps(data)

    try:
        if section == 'SickBeard':
            logger.debug(
                'Opening URL: {0} with params: {1}'.format(url, fork_params),
                section)
            s = requests.Session()
            if not apikey and username and password:
                login = '******'.format(protocol, host, port,
                                                     web_root)
                login_params = {'username': username, 'password': password}
                r = s.get(login, verify=False, timeout=(30, 60))
                if r.status_code in [401, 403] and r.cookies.get('_xsrf'):
                    login_params['_xsrf'] = r.cookies.get('_xsrf')
                s.post(login,
                       data=login_params,
                       stream=True,
                       verify=False,
                       timeout=(30, 60))
            r = s.get(url,
                      auth=(username, password),
                      params=fork_params,
                      stream=True,
                      verify=False,
                      timeout=(30, 1800))
        elif section == 'NzbDrone':
            logger.debug('Opening URL: {0} with data: {1}'.format(url, data),
                         section)
            r = requests.post(url,
                              data=data,
                              headers=headers,
                              stream=True,
                              verify=False,
                              timeout=(30, 1800))
    except requests.ConnectionError:
        logger.error('Unable to open URL: {0}'.format(url), section)
        return ProcessResult(
            message='{0}: Failed to post-process - Unable to connect to {0}'.
            format(section),
            status_code=1,
        )

    if r.status_code not in [
            requests.codes.ok, requests.codes.created, requests.codes.accepted
    ]:
        logger.error('Server returned status {0}'.format(r.status_code),
                     section)
        return ProcessResult(
            message='{0}: Failed to post-process - Server returned status {1}'.
            format(section, r.status_code),
            status_code=1,
        )

    success = False
    queued = False
    started = False
    if section == 'SickBeard':
        if apikey:
            if r.json()['result'] == 'success':
                success = True
        else:
            for line in r.iter_lines():
                if line:
                    line = line.decode('utf-8')
                    logger.postprocess('{0}'.format(line), section)
                    if 'Moving file from' in line:
                        input_name = os.path.split(line)[1]
                    if 'added to the queue' in line:
                        queued = True
                    if 'Processing succeeded' in line or 'Successfully processed' in line:
                        success = True

        if queued:
            time.sleep(60)
    elif section == 'NzbDrone':
        try:
            res = r.json()
            scan_id = int(res['id'])
            logger.debug('Scan started with id: {0}'.format(scan_id), section)
            started = True
        except Exception as e:
            logger.warning('No scan id was returned due to: {0}'.format(e),
                           section)
            scan_id = None
            started = False

    if status != 0 and delete_failed and not os.path.dirname(
            dir_name) == dir_name:
        logger.postprocess(
            'Deleting failed files and folder {0}'.format(dir_name), section)
        remove_dir(dir_name)

    if success:
        return ProcessResult(
            message='{0}: Successfully post-processed {1}'.format(
                section, input_name),
            status_code=0,
        )
    elif section == 'NzbDrone' and started:
        n = 0
        params = {}
        url = '{0}/{1}'.format(url, scan_id)
        while n < 6:  # set up wait_for minutes to see if command completes..
            time.sleep(10 * wait_for)
            command_status = command_complete(url, params, headers, section)
            if command_status and command_status in ['completed', 'failed']:
                break
            n += 1
        if command_status:
            logger.debug(
                'The Scan command return status: {0}'.format(command_status),
                section)
        if not os.path.exists(dir_name):
            logger.debug(
                'The directory {0} has been removed. Renaming was successful.'.
                format(dir_name), section)
            return ProcessResult(
                message='{0}: Successfully post-processed {1}'.format(
                    section, input_name),
                status_code=0,
            )
        elif command_status and command_status in ['completed']:
            logger.debug(
                'The Scan command has completed successfully. Renaming was successful.',
                section)
            return ProcessResult(
                message='{0}: Successfully post-processed {1}'.format(
                    section, input_name),
                status_code=0,
            )
        elif command_status and command_status in ['failed']:
            logger.debug(
                'The Scan command has failed. Renaming was not successful.',
                section)
            # return ProcessResult(
            #     message='{0}: Failed to post-process {1}'.format(section, input_name),
            #     status_code=1,
            # )
        if completed_download_handling(url2, headers, section=section):
            logger.debug(
                'The Scan command did not return status completed, but complete Download Handling is enabled. Passing back to {0}.'
                .format(section), section)
            return ProcessResult(
                message=
                '{0}: Complete DownLoad Handling is enabled. Passing back to {0}'
                .format(section),
                status_code=status,
            )
        else:
            logger.warning(
                'The Scan command did not return a valid status. Renaming was not successful.',
                section)
            return ProcessResult(
                message='{0}: Failed to post-process {1}'.format(
                    section, input_name),
                status_code=1,
            )
    else:
        return ProcessResult(
            message=
            '{0}: Failed to post-process - Returned log from {0} was not as expected.'
            .format(section),
            status_code=1,  # We did not receive Success confirmation.
        )
Beispiel #2
0
def process(section,
            dir_name,
            input_name=None,
            status=0,
            client_agent='manual',
            download_id='',
            input_category=None,
            failure_link=None):

    cfg = dict(core.CFG[section][input_category])

    host = cfg['host']
    port = cfg['port']
    apikey = cfg['apikey']
    if section == 'CouchPotato':
        method = cfg['method']
    else:
        method = None
    # added importMode for Radarr config
    if section == 'Radarr':
        import_mode = cfg.get('importMode', 'Move')
    else:
        import_mode = None
    delete_failed = int(cfg['delete_failed'])
    wait_for = int(cfg['wait_for'])
    ssl = int(cfg.get('ssl', 0))
    web_root = cfg.get('web_root', '')
    remote_path = int(cfg.get('remote_path', 0))
    protocol = 'https://' if ssl else 'http://'
    omdbapikey = cfg.get('omdbapikey', '')
    status = int(status)
    if status > 0 and core.NOEXTRACTFAILED:
        extract = 0
    else:
        extract = int(cfg.get('extract', 0))

    imdbid = find_imdbid(dir_name, input_name, omdbapikey)
    if section == 'CouchPotato':
        base_url = '{0}{1}:{2}{3}/api/{4}/'.format(protocol, host, port,
                                                   web_root, apikey)
    if section == 'Radarr':
        base_url = '{0}{1}:{2}{3}/api/command'.format(protocol, host, port,
                                                      web_root)
        url2 = '{0}{1}:{2}{3}/api/config/downloadClient'.format(
            protocol, host, port, web_root)
        headers = {'X-Api-Key': apikey}
    if section == 'Watcher3':
        base_url = '{0}{1}:{2}{3}/postprocessing'.format(
            protocol, host, port, web_root)
    if not apikey:
        logger.info(
            'No CouchPotato or Radarr apikey entered. Performing transcoder functions only'
        )
        release = None
    elif server_responding(base_url):
        if section == 'CouchPotato':
            release = get_release(base_url, imdbid, download_id)
        else:
            release = None
    else:
        logger.error('Server did not respond. Exiting', section)
        return ProcessResult(
            message='{0}: Failed to post-process - {0} did not respond.'.
            format(section),
            status_code=1,
        )

    # pull info from release found if available
    release_id = None
    media_id = None
    downloader = None
    release_status_old = None
    if release:
        try:
            release_id = list(release.keys())[0]
            media_id = release[release_id]['media_id']
            download_id = release[release_id]['download_info']['id']
            downloader = release[release_id]['download_info']['downloader']
            release_status_old = release[release_id]['status']
        except Exception:
            pass

    if not os.path.isdir(dir_name) and os.path.isfile(
            dir_name
    ):  # If the input directory is a file, assume single file download and split dir/name.
        dir_name = os.path.split(os.path.normpath(dir_name))[0]

    specific_path = os.path.join(dir_name, str(input_name))
    clean_name = os.path.splitext(specific_path)
    if clean_name[1] == '.nzb':
        specific_path = clean_name[0]
    if os.path.isdir(specific_path):
        dir_name = specific_path

    process_all_exceptions(input_name, dir_name)
    input_name, dir_name = convert_to_ascii(input_name, dir_name)

    if not list_media_files(
            dir_name, media=True, audio=False, meta=False,
            archives=False) and list_media_files(
                dir_name, media=False, audio=False, meta=False,
                archives=True) and extract:
        logger.debug(
            'Checking for archives to extract in directory: {0}'.format(
                dir_name))
        core.extract_files(dir_name)
        input_name, dir_name = convert_to_ascii(input_name, dir_name)

    good_files = 0
    num_files = 0
    # Check video files for corruption
    for video in list_media_files(dir_name,
                                  media=True,
                                  audio=False,
                                  meta=False,
                                  archives=False):
        num_files += 1
        if transcoder.is_video_good(video, status):
            import_subs(video)
            good_files += 1
    if num_files and good_files == num_files:
        if status:
            logger.info(
                'Status shown as failed from Downloader, but {0} valid video files found. Setting as success.'
                .format(good_files), section)
            status = 0
    elif num_files and good_files < num_files:
        logger.info(
            'Status shown as success from Downloader, but corrupt video files found. Setting as failed.',
            section)
        if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][
                0:5] >= '14.0':
            print('[NZB] MARK=BAD')
        if failure_link:
            failure_link += '&corrupt=true'
        status = 1
    elif client_agent == 'manual':
        logger.warning(
            'No media files found in directory {0} to manually process.'.
            format(dir_name), section)
        return ProcessResult(
            message='',
            status_code=0,  # Success (as far as this script is concerned)
        )
    else:
        logger.warning(
            'No media files found in directory {0}. Processing this as a failed download'
            .format(dir_name), section)
        status = 1
        if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][
                0:5] >= '14.0':
            print('[NZB] MARK=BAD')

    if status == 0:
        if core.TRANSCODE == 1:
            result, new_dir_name = transcoder.transcode_directory(dir_name)
            if result == 0:
                logger.debug(
                    'Transcoding succeeded for files in {0}'.format(dir_name),
                    section)
                dir_name = new_dir_name

                chmod_directory = int(str(cfg.get('chmodDirectory', '0')), 8)
                logger.debug(
                    'Config setting \'chmodDirectory\' currently set to {0}'.
                    format(oct(chmod_directory)), section)
                if chmod_directory:
                    logger.info(
                        'Attempting to set the octal permission of \'{0}\' on directory \'{1}\''
                        .format(oct(chmod_directory), dir_name), section)
                    core.rchmod(dir_name, chmod_directory)
            else:
                logger.error(
                    'Transcoding failed for files in {0}'.format(dir_name),
                    section)
                return ProcessResult(
                    message='{0}: Failed to post-process - Transcoding failed'.
                    format(section),
                    status_code=1,
                )
        for video in list_media_files(dir_name,
                                      media=True,
                                      audio=False,
                                      meta=False,
                                      archives=False):
            if not release and '.cp(tt' not in video and imdbid:
                video_name, video_ext = os.path.splitext(video)
                video2 = '{0}.cp({1}){2}'.format(video_name, imdbid, video_ext)
                if not (client_agent in [core.TORRENT_CLIENT_AGENT, 'manual']
                        and core.USE_LINK == 'move-sym'):
                    logger.debug('Renaming: {0} to: {1}'.format(video, video2))
                    os.rename(video, video2)

        if not apikey:  # If only using Transcoder functions, exit here.
            logger.info(
                'No CouchPotato or Radarr or Watcher3 apikey entered. Processing completed.'
            )
            return ProcessResult(
                message='{0}: Successfully post-processed {1}'.format(
                    section, input_name),
                status_code=0,
            )

        params = {
            'media_folder': remote_dir(dir_name) if remote_path else dir_name,
        }

        if download_id and release_id:
            params['downloader'] = downloader or client_agent
            params['download_id'] = download_id

        if section == 'CouchPotato':
            if method == 'manage':
                command = 'manage.update'
                params.clear()
            else:
                command = 'renamer.scan'

            url = '{0}{1}'.format(base_url, command)
            logger.debug(
                'Opening URL: {0} with PARAMS: {1}'.format(url, params),
                section)
            logger.postprocess(
                'Starting {0} scan for {1}'.format(method, input_name),
                section)

        if section == 'Radarr':
            payload = {
                'name': 'DownloadedMoviesScan',
                'path': params['media_folder'],
                'downloadClientId': download_id,
                'importMode': import_mode
            }
            if not download_id:
                payload.pop('downloadClientId')
            logger.debug(
                'Opening URL: {0} with PARAMS: {1}'.format(base_url, payload),
                section)
            logger.postprocess(
                'Starting DownloadedMoviesScan scan for {0}'.format(
                    input_name), section)

        if section == 'Watcher3':
            if input_name and os.path.isfile(os.path.join(
                    dir_name, input_name)):
                params['media_folder'] = os.path.join(params['media_folder'],
                                                      input_name)
            payload = {
                'apikey': apikey,
                'path': params['media_folder'],
                'guid': download_id,
                'mode': 'complete'
            }
            if not download_id:
                payload.pop('guid')
            logger.debug(
                'Opening URL: {0} with PARAMS: {1}'.format(base_url, payload),
                section)
            logger.postprocess(
                'Starting postprocessing scan for {0}'.format(input_name),
                section)

        try:
            if section == 'CouchPotato':
                r = requests.get(url,
                                 params=params,
                                 verify=False,
                                 timeout=(30, 1800))
            elif section == 'Watcher3':
                r = requests.post(base_url,
                                  data=payload,
                                  verify=False,
                                  timeout=(30, 1800))
            else:
                r = requests.post(base_url,
                                  data=json.dumps(payload),
                                  headers=headers,
                                  stream=True,
                                  verify=False,
                                  timeout=(30, 1800))
        except requests.ConnectionError:
            logger.error('Unable to open URL', section)
            return ProcessResult(
                message='{0}: Failed to post-process - Unable to connect to {0}'
                .format(section),
                status_code=1,
            )

        result = r.json()
        if r.status_code not in [
                requests.codes.ok, requests.codes.created,
                requests.codes.accepted
        ]:
            logger.error('Server returned status {0}'.format(r.status_code),
                         section)
            return ProcessResult(
                message=
                '{0}: Failed to post-process - Server returned status {1}'.
                format(section, r.status_code),
                status_code=1,
            )
        elif section == 'CouchPotato' and result['success']:
            logger.postprocess(
                'SUCCESS: Finished {0} scan for folder {1}'.format(
                    method, dir_name), section)
            if method == 'manage':
                return ProcessResult(
                    message='{0}: Successfully post-processed {1}'.format(
                        section, input_name),
                    status_code=0,
                )
        elif section == 'Radarr':
            logger.postprocess('Radarr response: {0}'.format(result['state']))
            try:
                scan_id = int(result['id'])
                logger.debug('Scan started with id: {0}'.format(scan_id),
                             section)
            except Exception as e:
                logger.warning('No scan id was returned due to: {0}'.format(e),
                               section)
                scan_id = None
        elif section == 'Watcher3' and result['status'] == 'finished':
            logger.postprocess('Watcher3 updated status to {0}'.format(
                result['tasks']['update_movie_status']))
            if result['tasks']['update_movie_status'] == 'Finished':
                return ProcessResult(
                    message='{0}: Successfully post-processed {1}'.format(
                        section, input_name),
                    status_code=status,
                )
            else:
                return ProcessResult(
                    message='{0}: Failed to post-process - changed status to {1}'
                    .format(section, result['tasks']['update_movie_status']),
                    status_code=1,
                )
        else:
            logger.error(
                'FAILED: {0} scan was unable to finish for folder {1}. exiting!'
                .format(method, dir_name), section)
            return ProcessResult(
                message=
                '{0}: Failed to post-process - Server did not return success'.
                format(section),
                status_code=1,
            )
    else:
        core.FAILED = True
        logger.postprocess(
            'FAILED DOWNLOAD DETECTED FOR {0}'.format(input_name), section)
        if failure_link:
            report_nzb(failure_link, client_agent)

        if section == 'Radarr':
            logger.postprocess(
                'SUCCESS: Sending failed download to {0} for CDH processing'.
                format(section), section)
            return ProcessResult(
                message='{0}: Sending failed download back to {0}'.format(
                    section),
                status_code=
                1,  # Return as failed to flag this in the downloader.
            )  # Return failed flag, but log the event as successful.
        elif section == 'Watcher3':
            logger.postprocess(
                'Sending failed download to {0} for CDH processing'.format(
                    section), section)
            path = remote_dir(dir_name) if remote_path else dir_name
            if input_name and os.path.isfile(os.path.join(
                    dir_name, input_name)):
                path = os.path.join(path, input_name)
            payload = {
                'apikey': apikey,
                'path': path,
                'guid': download_id,
                'mode': 'failed'
            }
            r = requests.post(base_url,
                              data=payload,
                              verify=False,
                              timeout=(30, 1800))
            result = r.json()
            logger.postprocess('Watcher3 response: {0}'.format(result))
            if result['status'] == 'finished':
                return ProcessResult(
                    message='{0}: Sending failed download back to {0}'.format(
                        section),
                    status_code=
                    1,  # Return as failed to flag this in the downloader.
                )  # Return failed flag, but log the event as successful.

        if delete_failed and os.path.isdir(
                dir_name) and not os.path.dirname(dir_name) == dir_name:
            logger.postprocess(
                'Deleting failed files and folder {0}'.format(dir_name),
                section)
            remove_dir(dir_name)

        if not release_id and not media_id:
            logger.error(
                'Could not find a downloaded movie in the database matching {0}, exiting!'
                .format(input_name), section)
            return ProcessResult(
                message=
                '{0}: Failed to post-process - Failed download not found in {0}'
                .format(section),
                status_code=1,
            )

        if release_id:
            logger.postprocess(
                'Setting failed release {0} to ignored ...'.format(input_name),
                section)

            url = '{url}release.ignore'.format(url=base_url)
            params = {'id': release_id}

            logger.debug(
                'Opening URL: {0} with PARAMS: {1}'.format(url, params),
                section)

            try:
                r = requests.get(url,
                                 params=params,
                                 verify=False,
                                 timeout=(30, 120))
            except requests.ConnectionError:
                logger.error('Unable to open URL {0}'.format(url), section)
                return ProcessResult(
                    message=
                    '{0}: Failed to post-process - Unable to connect to {0}'.
                    format(section),
                    status_code=1,
                )

            result = r.json()
            if r.status_code not in [
                    requests.codes.ok, requests.codes.created,
                    requests.codes.accepted
            ]:
                logger.error(
                    'Server returned status {0}'.format(r.status_code),
                    section)
                return ProcessResult(
                    status_code=1,
                    message=
                    '{0}: Failed to post-process - Server returned status {1}'.
                    format(section, r.status_code),
                )
            elif result['success']:
                logger.postprocess(
                    'SUCCESS: {0} has been set to ignored ...'.format(
                        input_name), section)
            else:
                logger.warning(
                    'FAILED: Unable to set {0} to ignored!'.format(input_name),
                    section)
                return ProcessResult(
                    message=
                    '{0}: Failed to post-process - Unable to set {1} to ignored'
                    .format(section, input_name),
                    status_code=1,
                )

        logger.postprocess('Trying to snatch the next highest ranked release.',
                           section)

        url = '{0}movie.searcher.try_next'.format(base_url)
        logger.debug('Opening URL: {0}'.format(url), section)

        try:
            r = requests.get(url,
                             params={'media_id': media_id},
                             verify=False,
                             timeout=(30, 600))
        except requests.ConnectionError:
            logger.error('Unable to open URL {0}'.format(url), section)
            return ProcessResult(
                message='{0}: Failed to post-process - Unable to connect to {0}'
                .format(section),
                status_code=1,
            )

        result = r.json()
        if r.status_code not in [
                requests.codes.ok, requests.codes.created,
                requests.codes.accepted
        ]:
            logger.error('Server returned status {0}'.format(r.status_code),
                         section)
            return ProcessResult(
                message=
                '{0}: Failed to post-process - Server returned status {1}'.
                format(section, r.status_code),
                status_code=1,
            )
        elif result['success']:
            logger.postprocess(
                'SUCCESS: Snatched the next highest release ...', section)
            return ProcessResult(
                message='{0}: Successfully snatched next highest release'.
                format(section),
                status_code=0,
            )
        else:
            logger.postprocess(
                'SUCCESS: Unable to find a new release to snatch now. CP will keep searching!',
                section)
            return ProcessResult(
                status_code=0,
                message='{0}: No new release found now. {0} will keep searching'
                .format(section),
            )

    # Added a release that was not in the wanted list so confirm rename successful by finding this movie media.list.
    if not release:
        download_id = None  # we don't want to filter new releases based on this.

    # we will now check to see if CPS has finished renaming before returning to TorrentToMedia and unpausing.
    timeout = time.time() + 60 * wait_for
    while time.time() < timeout:  # only wait 2 (default) minutes, then return.
        logger.postprocess('Checking for status change, please stand by ...',
                           section)
        if section == 'CouchPotato':
            release = get_release(base_url, imdbid, download_id, release_id)
            scan_id = None
        else:
            release = None
        if release:
            try:
                release_id = list(release.keys())[0]
                title = release[release_id]['title']
                release_status_new = release[release_id]['status']
                if release_status_old is None:  # we didn't have a release before, but now we do.
                    logger.postprocess(
                        'SUCCESS: Movie {0} has now been added to CouchPotato with release status of [{1}]'
                        .format(title,
                                str(release_status_new).upper()), section)
                    return ProcessResult(
                        message='{0}: Successfully post-processed {1}'.format(
                            section, input_name),
                        status_code=0,
                    )

                if release_status_new != release_status_old:
                    logger.postprocess(
                        'SUCCESS: Release for {0} has now been marked with a status of [{1}]'
                        .format(title,
                                str(release_status_new).upper()), section)
                    return ProcessResult(
                        message='{0}: Successfully post-processed {1}'.format(
                            section, input_name),
                        status_code=0,
                    )
            except Exception:
                pass
        elif scan_id:
            url = '{0}/{1}'.format(base_url, scan_id)
            command_status = command_complete(url, params, headers, section)
            if command_status:
                logger.debug(
                    'The Scan command return status: {0}'.format(
                        command_status), section)
                if command_status in ['completed']:
                    logger.debug(
                        'The Scan command has completed successfully. Renaming was successful.',
                        section)
                    return ProcessResult(
                        message='{0}: Successfully post-processed {1}'.format(
                            section, input_name),
                        status_code=0,
                    )
                elif command_status in ['failed']:
                    logger.debug(
                        'The Scan command has failed. Renaming was not successful.',
                        section)
                    # return ProcessResult(
                    #     message='{0}: Failed to post-process {1}'.format(section, input_name),
                    #     status_code=1,
                    # )

        if not os.path.isdir(dir_name):
            logger.postprocess(
                'SUCCESS: Input Directory [{0}] has been processed and removed'
                .format(dir_name), section)
            return ProcessResult(
                status_code=0,
                message='{0}: Successfully post-processed {1}'.format(
                    section, input_name),
            )

        elif not list_media_files(
                dir_name, media=True, audio=False, meta=False, archives=True):
            logger.postprocess(
                'SUCCESS: Input Directory [{0}] has no remaining media files. This has been fully processed.'
                .format(dir_name), section)
            return ProcessResult(
                message='{0}: Successfully post-processed {1}'.format(
                    section, input_name),
                status_code=0,
            )

        # pause and let CouchPotatoServer/Radarr catch its breath
        time.sleep(10 * wait_for)

    # The status hasn't changed. we have waited wait_for minutes which is more than enough. uTorrent can resume seeding now.
    if section == 'Radarr' and completed_download_handling(
            url2, headers, section=section):
        logger.debug(
            'The Scan command did not return status completed, but complete Download Handling is enabled. Passing back to {0}.'
            .format(section), section)
        return ProcessResult(
            message=
            '{0}: Complete DownLoad Handling is enabled. Passing back to {0}'.
            format(section),
            status_code=status,
        )
    logger.warning(
        '{0} does not appear to have changed status after {1} minutes, Please check your logs.'
        .format(input_name, wait_for),
        section,
    )
    return ProcessResult(
        status_code=1,
        message='{0}: Failed to post-process - No change in status'.format(
            section),
    )
Beispiel #3
0
def process(section, dir_name, input_name=None, status=0, client_agent='manual', download_id='', input_category=None, failure_link=None):

    cfg = dict(core.CFG[section][input_category])

    host = cfg['host']
    port = cfg['port']
    apikey = cfg['apikey']
    if section == 'CouchPotato':
        method = cfg['method']
    else:
        method = None
    # added importMode for Radarr config
    if section == 'Radarr':
        import_mode = cfg.get('importMode', 'Move')
    else:
        import_mode = None
    delete_failed = int(cfg['delete_failed'])
    wait_for = int(cfg['wait_for'])
    ssl = int(cfg.get('ssl', 0))
    web_root = cfg.get('web_root', '')
    remote_path = int(cfg.get('remote_path', 0))
    protocol = 'https://' if ssl else 'http://'
    omdbapikey = cfg.get('omdbapikey', '')
    status = int(status)
    if status > 0 and core.NOEXTRACTFAILED:
        extract = 0
    else:
        extract = int(cfg.get('extract', 0))

    imdbid = find_imdbid(dir_name, input_name, omdbapikey)
    if section == 'CouchPotato':
        base_url = '{0}{1}:{2}{3}/api/{4}/'.format(protocol, host, port, web_root, apikey)
    if section == 'Radarr':
        base_url = '{0}{1}:{2}{3}/api/command'.format(protocol, host, port, web_root)
        url2 = '{0}{1}:{2}{3}/api/config/downloadClient'.format(protocol, host, port, web_root)
        headers = {'X-Api-Key': apikey}
    if not apikey:
        logger.info('No CouchPotato or Radarr apikey entered. Performing transcoder functions only')
        release = None
    elif server_responding(base_url):
        if section == 'CouchPotato':
            release = get_release(base_url, imdbid, download_id)
        else:
            release = None
    else:
        logger.error('Server did not respond. Exiting', section)
        return ProcessResult(
            message='{0}: Failed to post-process - {0} did not respond.'.format(section),
            status_code=1,
        )

    # pull info from release found if available
    release_id = None
    media_id = None
    downloader = None
    release_status_old = None
    if release:
        try:
            release_id = list(release.keys())[0]
            media_id = release[release_id]['media_id']
            download_id = release[release_id]['download_info']['id']
            downloader = release[release_id]['download_info']['downloader']
            release_status_old = release[release_id]['status']
        except Exception:
            pass

    if not os.path.isdir(dir_name) and os.path.isfile(dir_name):  # If the input directory is a file, assume single file download and split dir/name.
        dir_name = os.path.split(os.path.normpath(dir_name))[0]

    specific_path = os.path.join(dir_name, str(input_name))
    clean_name = os.path.splitext(specific_path)
    if clean_name[1] == '.nzb':
        specific_path = clean_name[0]
    if os.path.isdir(specific_path):
        dir_name = specific_path

    process_all_exceptions(input_name, dir_name)
    input_name, dir_name = convert_to_ascii(input_name, dir_name)

    if not list_media_files(dir_name, media=True, audio=False, meta=False, archives=False) and list_media_files(dir_name, media=False, audio=False, meta=False, archives=True) and extract:
        logger.debug('Checking for archives to extract in directory: {0}'.format(dir_name))
        core.extract_files(dir_name)
        input_name, dir_name = convert_to_ascii(input_name, dir_name)

    good_files = 0
    num_files = 0
    # Check video files for corruption
    for video in list_media_files(dir_name, media=True, audio=False, meta=False, archives=False):
        num_files += 1
        if transcoder.is_video_good(video, status):
            import_subs(video)
            good_files += 1
    if num_files and good_files == num_files:
        if status:
            logger.info('Status shown as failed from Downloader, but {0} valid video files found. Setting as success.'.format(good_files), section)
            status = 0
    elif num_files and good_files < num_files:
        logger.info('Status shown as success from Downloader, but corrupt video files found. Setting as failed.', section)
        if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][0:5] >= '14.0':
            print('[NZB] MARK=BAD')
        if failure_link:
            failure_link += '&corrupt=true'
        status = 1
    elif client_agent == 'manual':
        logger.warning('No media files found in directory {0} to manually process.'.format(dir_name), section)
        return ProcessResult(
            message='',
            status_code=0,  # Success (as far as this script is concerned)
        )
    else:
        logger.warning('No media files found in directory {0}. Processing this as a failed download'.format(dir_name), section)
        status = 1
        if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][0:5] >= '14.0':
            print('[NZB] MARK=BAD')

    if status == 0:
        if core.TRANSCODE == 1:
            result, new_dir_name = transcoder.transcode_directory(dir_name)
            if result == 0:
                logger.debug('Transcoding succeeded for files in {0}'.format(dir_name), section)
                dir_name = new_dir_name

                chmod_directory = int(str(cfg.get('chmodDirectory', '0')), 8)
                logger.debug('Config setting \'chmodDirectory\' currently set to {0}'.format(oct(chmod_directory)), section)
                if chmod_directory:
                    logger.info('Attempting to set the octal permission of \'{0}\' on directory \'{1}\''.format(oct(chmod_directory), dir_name), section)
                    core.rchmod(dir_name, chmod_directory)
            else:
                logger.error('Transcoding failed for files in {0}'.format(dir_name), section)
                return ProcessResult(
                    message='{0}: Failed to post-process - Transcoding failed'.format(section),
                    status_code=1,
                )
        for video in list_media_files(dir_name, media=True, audio=False, meta=False, archives=False):
            if not release and '.cp(tt' not in video and imdbid:
                video_name, video_ext = os.path.splitext(video)
                video2 = '{0}.cp({1}){2}'.format(video_name, imdbid, video_ext)
                if not (client_agent in [core.TORRENT_CLIENTAGENT, 'manual'] and core.USELINK == 'move-sym'):
                    logger.debug('Renaming: {0} to: {1}'.format(video, video2))
                    os.rename(video, video2)

        if not apikey:  # If only using Transcoder functions, exit here.
            logger.info('No CouchPotato or Radarr apikey entered. Processing completed.')
            return ProcessResult(
                message='{0}: Successfully post-processed {1}'.format(section, input_name),
                status_code=0,
            )

        params = {}
        if download_id and release_id:
            params['downloader'] = downloader or client_agent
            params['download_id'] = download_id

        params['media_folder'] = remote_dir(dir_name) if remote_path else dir_name

        if section == 'CouchPotato':
            if method == 'manage':
                command = 'manage.update'
                params = {}
            else:
                command = 'renamer.scan'

            url = '{0}{1}'.format(base_url, command)
            logger.debug('Opening URL: {0} with PARAMS: {1}'.format(url, params), section)
            logger.postprocess('Starting {0} scan for {1}'.format(method, input_name), section)

        if section == 'Radarr':
            payload = {'name': 'DownloadedMoviesScan', 'path': params['media_folder'], 'downloadClientId': download_id, 'importMode': import_mode}
            if not download_id:
                payload.pop('downloadClientId')
            logger.debug('Opening URL: {0} with PARAMS: {1}'.format(base_url, payload), section)
            logger.postprocess('Starting DownloadedMoviesScan scan for {0}'.format(input_name), section)

        try:
            if section == 'CouchPotato':
                r = requests.get(url, params=params, verify=False, timeout=(30, 1800))
            else:
                r = requests.post(base_url, data=json.dumps(payload), headers=headers, stream=True, verify=False, timeout=(30, 1800))
        except requests.ConnectionError:
            logger.error('Unable to open URL', section)
            return ProcessResult(
                message='{0}: Failed to post-process - Unable to connect to {0}'.format(section),
                status_code=1,
            )

        result = r.json()
        if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
            logger.error('Server returned status {0}'.format(r.status_code), section)
            return ProcessResult(
                message='{0}: Failed to post-process - Server returned status {1}'.format(section, r.status_code),
                status_code=1,
            )
        elif section == 'CouchPotato' and result['success']:
            logger.postprocess('SUCCESS: Finished {0} scan for folder {1}'.format(method, dir_name), section)
            if method == 'manage':
                return ProcessResult(
                    message='{0}: Successfully post-processed {1}'.format(section, input_name),
                    status_code=0,
                )
        elif section == 'Radarr':
            logger.postprocess('Radarr response: {0}'.format(result['state']))
            try:
                res = json.loads(r.content)
                scan_id = int(res['id'])
                logger.debug('Scan started with id: {0}'.format(scan_id), section)
                started = True
            except Exception as e:
                logger.warning('No scan id was returned due to: {0}'.format(e), section)
                scan_id = None
        else:
            logger.error('FAILED: {0} scan was unable to finish for folder {1}. exiting!'.format(method, dir_name),
                         section)
            return ProcessResult(
                message='{0}: Failed to post-process - Server did not return success'.format(section),
                status_code=1,
            )
    else:
        core.FAILED = True
        logger.postprocess('FAILED DOWNLOAD DETECTED FOR {0}'.format(input_name), section)
        if failure_link:
            report_nzb(failure_link, client_agent)

        if section == 'Radarr':
            logger.postprocess('FAILED: The download failed. Sending failed download to {0} for CDH processing'.format(section), section)
            return ProcessResult(
                message='{0}: Download Failed. Sending back to {0}'.format(section),
                status_code=1,  # Return as failed to flag this in the downloader.
            )

        if delete_failed and os.path.isdir(dir_name) and not os.path.dirname(dir_name) == dir_name:
            logger.postprocess('Deleting failed files and folder {0}'.format(dir_name), section)
            remove_dir(dir_name)

        if not release_id and not media_id:
            logger.error('Could not find a downloaded movie in the database matching {0}, exiting!'.format(input_name),
                         section)
            return ProcessResult(
                message='{0}: Failed to post-process - Failed download not found in {0}'.format(section),
                status_code=1,
            )

        if release_id:
            logger.postprocess('Setting failed release {0} to ignored ...'.format(input_name), section)

            url = '{url}release.ignore'.format(url=base_url)
            params = {'id': release_id}

            logger.debug('Opening URL: {0} with PARAMS: {1}'.format(url, params), section)

            try:
                r = requests.get(url, params=params, verify=False, timeout=(30, 120))
            except requests.ConnectionError:
                logger.error('Unable to open URL {0}'.format(url), section)
                return ProcessResult(
                    message='{0}: Failed to post-process - Unable to connect to {0}'.format(section),
                    status_code=1,
                )

            result = r.json()
            if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
                logger.error('Server returned status {0}'.format(r.status_code), section)
                return ProcessResult(
                    status_code=1,
                    message='{0}: Failed to post-process - Server returned status {1}'.format(section, r.status_code),
                )
            elif result['success']:
                logger.postprocess('SUCCESS: {0} has been set to ignored ...'.format(input_name), section)
            else:
                logger.warning('FAILED: Unable to set {0} to ignored!'.format(input_name), section)
                return ProcessResult(
                    message='{0}: Failed to post-process - Unable to set {1} to ignored'.format(section, input_name),
                    status_code=1,
                )

        logger.postprocess('Trying to snatch the next highest ranked release.', section)

        url = '{0}movie.searcher.try_next'.format(base_url)
        logger.debug('Opening URL: {0}'.format(url), section)

        try:
            r = requests.get(url, params={'media_id': media_id}, verify=False, timeout=(30, 600))
        except requests.ConnectionError:
            logger.error('Unable to open URL {0}'.format(url), section)
            return ProcessResult(
                message='{0}: Failed to post-process - Unable to connect to {0}'.format(section),
                status_code=1,
            )

        result = r.json()
        if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
            logger.error('Server returned status {0}'.format(r.status_code), section)
            return ProcessResult(
                message='{0}: Failed to post-process - Server returned status {1}'.format(section, r.status_code),
                status_code=1,
            )
        elif result['success']:
            logger.postprocess('SUCCESS: Snatched the next highest release ...', section)
            return ProcessResult(
                message='{0}: Successfully snatched next highest release'.format(section),
                status_code=0,
            )
        else:
            logger.postprocess('SUCCESS: Unable to find a new release to snatch now. CP will keep searching!', section)
            return ProcessResult(
                status_code=0,
                message='{0}: No new release found now. {0} will keep searching'.format(section),
            )

    # Added a release that was not in the wanted list so confirm rename successful by finding this movie media.list.
    if not release:
        download_id = None  # we don't want to filter new releases based on this.

    # we will now check to see if CPS has finished renaming before returning to TorrentToMedia and unpausing.
    timeout = time.time() + 60 * wait_for
    while time.time() < timeout:  # only wait 2 (default) minutes, then return.
        logger.postprocess('Checking for status change, please stand by ...', section)
        if section == 'CouchPotato':
            release = get_release(base_url, imdbid, download_id, release_id)
            scan_id = None
        else:
            release = None
        if release:
            try:
                release_id = list(release.keys())[0]
                title = release[release_id]['title']
                release_status_new = release[release_id]['status']
                if release_status_old is None:  # we didn't have a release before, but now we do.
                    logger.postprocess('SUCCESS: Movie {0} has now been added to CouchPotato with release status of [{1}]'.format(
                        title, str(release_status_new).upper()), section)
                    return ProcessResult(
                        message='{0}: Successfully post-processed {1}'.format(section, input_name),
                        status_code=0,
                    )

                if release_status_new != release_status_old:
                    logger.postprocess('SUCCESS: Release for {0} has now been marked with a status of [{1}]'.format(
                        title, str(release_status_new).upper()), section)
                    return ProcessResult(
                        message='{0}: Successfully post-processed {1}'.format(section, input_name),
                        status_code=0,
                    )
            except Exception:
                pass
        elif scan_id:
                url = '{0}/{1}'.format(base_url, scan_id)
                command_status = command_complete(url, params, headers, section)
                if command_status:
                    logger.debug('The Scan command return status: {0}'.format(command_status), section)
                    if command_status in ['completed']:
                        logger.debug('The Scan command has completed successfully. Renaming was successful.', section)
                        return [0, '{0}: Successfully post-processed {1}'.format(section, input_name)]
                    elif command_status in ['failed']:
                        logger.debug('The Scan command has failed. Renaming was not successful.', section)
                        # return ProcessResult(
                        #     message='{0}: Failed to post-process {1}'.format(section, input_name),
                        #     status_code=1,
                        # )

        if not os.path.isdir(dir_name):
            logger.postprocess('SUCCESS: Input Directory [{0}] has been processed and removed'.format(
                dir_name), section)
            return ProcessResult(
                status_code=0,
                message='{0}: Successfully post-processed {1}'.format(section, input_name),
            )

        elif not list_media_files(dir_name, media=True, audio=False, meta=False, archives=True):
            logger.postprocess('SUCCESS: Input Directory [{0}] has no remaining media files. This has been fully processed.'.format(
                dir_name), section)
            return ProcessResult(
                message='{0}: Successfully post-processed {1}'.format(section, input_name),
                status_code=0,
            )

        # pause and let CouchPotatoServer/Radarr catch its breath
        time.sleep(10 * wait_for)

    # The status hasn't changed. we have waited wait_for minutes which is more than enough. uTorrent can resume seeding now.
    if section == 'Radarr' and completed_download_handling(url2, headers, section=section):
        logger.debug('The Scan command did not return status completed, but complete Download Handling is enabled. Passing back to {0}.'.format(section), section)
        return ProcessResult(
            message='{0}: Complete DownLoad Handling is enabled. Passing back to {0}'.format(section),
            status_code=status,
        )
    logger.warning(
        '{0} does not appear to have changed status after {1} minutes, Please check your logs.'.format(input_name, wait_for),
        section,
    )
    return ProcessResult(
        status_code=1,
        message='{0}: Failed to post-process - No change in status'.format(section),
    )
Beispiel #4
0
def process(section, dir_name, input_name=None, failed=False, client_agent='manual', download_id=None, input_category=None, failure_link=None):

    cfg = dict(core.CFG[section][input_category])

    host = cfg['host']
    port = cfg['port']
    ssl = int(cfg.get('ssl', 0))
    web_root = cfg.get('web_root', '')
    protocol = 'https://' if ssl else 'http://'
    username = cfg.get('username', '')
    password = cfg.get('password', '')
    apikey = cfg.get('apikey', '')

    if server_responding('{0}{1}:{2}{3}'.format(protocol, host, port, web_root)):
        # auto-detect correct fork
        fork, fork_params = auto_fork(section, input_category)
    elif not username and not apikey:
        logger.info('No SickBeard username or Sonarr apikey entered. Performing transcoder functions only')
        fork, fork_params = 'None', {}
    else:
        logger.error('Server did not respond. Exiting', section)
        return ProcessResult(
            status_code=1,
            message='{0}: Failed to post-process - {0} did not respond.'.format(section),
        )

    delete_failed = int(cfg.get('delete_failed', 0))
    nzb_extraction_by = cfg.get('nzbExtractionBy', 'Downloader')
    process_method = cfg.get('process_method')
    if client_agent == core.TORRENT_CLIENT_AGENT and core.USE_LINK == 'move-sym':
        process_method = 'symlink'
    remote_path = int(cfg.get('remote_path', 0))
    wait_for = int(cfg.get('wait_for', 2))
    force = int(cfg.get('force', 0))
    delete_on = int(cfg.get('delete_on', 0))
    ignore_subs = int(cfg.get('ignore_subs', 0))
    status = int(failed)
    if status > 0 and core.NOEXTRACTFAILED:
        extract = 0
    else:
        extract = int(cfg.get('extract', 0))
    # get importmode, default to 'Move' for consistency with legacy
    import_mode = cfg.get('importMode', 'Move')

    if not os.path.isdir(dir_name) and os.path.isfile(dir_name):  # If the input directory is a file, assume single file download and split dir/name.
        dir_name = os.path.split(os.path.normpath(dir_name))[0]

    specific_path = os.path.join(dir_name, str(input_name))
    clean_name = os.path.splitext(specific_path)
    if clean_name[1] == '.nzb':
        specific_path = clean_name[0]
    if os.path.isdir(specific_path):
        dir_name = specific_path

    # Attempt to create the directory if it doesn't exist and ignore any
    # error stating that it already exists. This fixes a bug where SickRage
    # won't process the directory because it doesn't exist.
    try:
        os.makedirs(dir_name)  # Attempt to create the directory
    except OSError as e:
        # Re-raise the error if it wasn't about the directory not existing
        if e.errno != errno.EEXIST:
            raise

    if 'process_method' not in fork_params or (client_agent in ['nzbget', 'sabnzbd'] and nzb_extraction_by != 'Destination'):
        if input_name:
            process_all_exceptions(input_name, dir_name)
            input_name, dir_name = convert_to_ascii(input_name, dir_name)

        # Now check if tv files exist in destination.
        if not list_media_files(dir_name, media=True, audio=False, meta=False, archives=False):
            if list_media_files(dir_name, media=False, audio=False, meta=False, archives=True) and extract:
                logger.debug('Checking for archives to extract in directory: {0}'.format(dir_name))
                core.extract_files(dir_name)
                input_name, dir_name = convert_to_ascii(input_name, dir_name)

        if list_media_files(dir_name, media=True, audio=False, meta=False, archives=False):  # Check that a video exists. if not, assume failed.
            flatten(dir_name)

    # Check video files for corruption
    good_files = 0
    num_files = 0
    for video in list_media_files(dir_name, media=True, audio=False, meta=False, archives=False):
        num_files += 1
        if transcoder.is_video_good(video, status):
            good_files += 1
            import_subs(video)
    if num_files > 0:
        if good_files == num_files and not status == 0:
            logger.info('Found Valid Videos. Setting status Success')
            status = 0
            failed = 0
        if good_files < num_files and status == 0:
            logger.info('Found corrupt videos. Setting status Failed')
            status = 1
            failed = 1
            if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][0:5] >= '14.0':
                print('[NZB] MARK=BAD')
            if failure_link:
                failure_link += '&corrupt=true'
    elif client_agent == 'manual':
        logger.warning('No media files found in directory {0} to manually process.'.format(dir_name), section)
        return ProcessResult(
            message='',
            status_code=0,  # Success (as far as this script is concerned)
        )
    elif nzb_extraction_by == 'Destination':
        logger.info('Check for media files ignored because nzbExtractionBy is set to Destination.')
        if int(failed) == 0:
            logger.info('Setting Status Success.')
            status = 0
            failed = 0
        else:
            logger.info('Downloader reported an error during download or verification. Processing this as a failed download.')
            status = 1
            failed = 1
    else:
        logger.warning('No media files found in directory {0}. Processing this as a failed download'.format(dir_name), section)
        status = 1
        failed = 1
        if 'NZBOP_VERSION' in os.environ and os.environ['NZBOP_VERSION'][0:5] >= '14.0':
            print('[NZB] MARK=BAD')

    if status == 0 and core.TRANSCODE == 1:  # only transcode successful downloads
        result, new_dir_name = transcoder.transcode_directory(dir_name)
        if result == 0:
            logger.debug('SUCCESS: Transcoding succeeded for files in {0}'.format(dir_name), section)
            dir_name = new_dir_name

            chmod_directory = int(str(cfg.get('chmodDirectory', '0')), 8)
            logger.debug('Config setting \'chmodDirectory\' currently set to {0}'.format(oct(chmod_directory)), section)
            if chmod_directory:
                logger.info('Attempting to set the octal permission of \'{0}\' on directory \'{1}\''.format(oct(chmod_directory), dir_name), section)
                core.rchmod(dir_name, chmod_directory)
        else:
            logger.error('FAILED: Transcoding failed for files in {0}'.format(dir_name), section)
            return ProcessResult(
                message='{0}: Failed to post-process - Transcoding failed'.format(section),
                status_code=1,
            )

    # configure SB params to pass
    fork_params['quiet'] = 1
    fork_params['proc_type'] = 'manual'
    if input_name is not None:
        fork_params['nzbName'] = input_name

    for param in copy.copy(fork_params):
        if param == 'failed':
            fork_params[param] = failed
            if 'proc_type' in fork_params:
                del fork_params['proc_type']
            if 'type' in fork_params:
                del fork_params['type']

        if param == 'return_data':
            fork_params[param] = 0
            if 'quiet' in fork_params:
                del fork_params['quiet']

        if param == 'type':
            fork_params[param] = 'manual'
            if 'proc_type' in fork_params:
                del fork_params['proc_type']

        if param in ['dir_name', 'dir', 'proc_dir', 'process_directory', 'path']:
            fork_params[param] = dir_name
            if remote_path:
                fork_params[param] = remote_dir(dir_name)

        if param == 'process_method':
            if process_method:
                fork_params[param] = process_method
            else:
                del fork_params[param]

        if param in ['force', 'force_replace']:
            if force:
                fork_params[param] = force
            else:
                del fork_params[param]

        if param in ['delete_on', 'delete']:
            if delete_on:
                fork_params[param] = delete_on
            else:
                del fork_params[param]

        if param == 'ignore_subs':
            if ignore_subs:
                fork_params[param] = ignore_subs
            else:
                del fork_params[param]

        if param == 'force_next':
            fork_params[param] = 1

    # delete any unused params so we don't pass them to SB by mistake
    [fork_params.pop(k) for k, v in list(fork_params.items()) if v is None]

    if status == 0:
        if section == 'NzbDrone' and not apikey:
            logger.info('No Sonarr apikey entered. Processing completed.')
            return ProcessResult(
                message='{0}: Successfully post-processed {1}'.format(section, input_name),
                status_code=0,
            )
        logger.postprocess('SUCCESS: The download succeeded, sending a post-process request', section)
    else:
        core.FAILED = True
        if failure_link:
            report_nzb(failure_link, client_agent)
        if 'failed' in fork_params:
            logger.postprocess('FAILED: The download failed. Sending \'failed\' process request to {0} branch'.format(fork), section)
        elif section == 'NzbDrone':
            logger.postprocess('FAILED: The download failed. Sending failed download to {0} for CDH processing'.format(fork), section)
            return ProcessResult(
                message='{0}: Download Failed. Sending back to {0}'.format(section),
                status_code=1,  # Return as failed to flag this in the downloader.
            )
        else:
            logger.postprocess('FAILED: The download failed. {0} branch does not handle failed downloads. Nothing to process'.format(fork), section)
            if delete_failed and os.path.isdir(dir_name) and not os.path.dirname(dir_name) == dir_name:
                logger.postprocess('Deleting failed files and folder {0}'.format(dir_name), section)
                remove_dir(dir_name)
            return ProcessResult(
                message='{0}: Failed to post-process. {0} does not support failed downloads'.format(section),
                status_code=1,  # Return as failed to flag this in the downloader.
            )

    url = None
    if section == 'SickBeard':
        if apikey:
            url = '{0}{1}:{2}{3}/api/{4}/?cmd=postprocess'.format(protocol, host, port, web_root, apikey)
        elif fork == 'Stheno':
            url = "{0}{1}:{2}{3}/home/postprocess/process_episode".format(protocol, host, port, web_root)
        else:
            url = '{0}{1}:{2}{3}/home/postprocess/processEpisode'.format(protocol, host, port, web_root)
    elif section == 'NzbDrone':
        url = '{0}{1}:{2}{3}/api/command'.format(protocol, host, port, web_root)
        url2 = '{0}{1}:{2}{3}/api/config/downloadClient'.format(protocol, host, port, web_root)
        headers = {'X-Api-Key': apikey}
        # params = {'sortKey': 'series.title', 'page': 1, 'pageSize': 1, 'sortDir': 'asc'}
        if remote_path:
            logger.debug('remote_path: {0}'.format(remote_dir(dir_name)), section)
            data = {'name': 'DownloadedEpisodesScan', 'path': remote_dir(dir_name), 'downloadClientId': download_id, 'importMode': import_mode}
        else:
            logger.debug('path: {0}'.format(dir_name), section)
            data = {'name': 'DownloadedEpisodesScan', 'path': dir_name, 'downloadClientId': download_id, 'importMode': import_mode}
        if not download_id:
            data.pop('downloadClientId')
        data = json.dumps(data)

    try:
        if section == 'SickBeard':
            logger.debug('Opening URL: {0} with params: {1}'.format(url, fork_params), section)
            s = requests.Session()
            if not apikey and username and password:
                login = '******'.format(protocol, host, port, web_root)
                login_params = {'username': username, 'password': password}
                r = s.get(login, verify=False, timeout=(30, 60))
                if r.status_code == 401 and r.cookies.get('_xsrf'):
                    login_params['_xsrf'] = r.cookies.get('_xsrf')
                s.post(login, data=login_params, stream=True, verify=False, timeout=(30, 60))
            r = s.get(url, auth=(username, password), params=fork_params, stream=True, verify=False, timeout=(30, 1800))
        elif section == 'NzbDrone':
            logger.debug('Opening URL: {0} with data: {1}'.format(url, data), section)
            r = requests.post(url, data=data, headers=headers, stream=True, verify=False, timeout=(30, 1800))
    except requests.ConnectionError:
        logger.error('Unable to open URL: {0}'.format(url), section)
        return ProcessResult(
            message='{0}: Failed to post-process - Unable to connect to {0}'.format(section),
            status_code=1,
        )

    if r.status_code not in [requests.codes.ok, requests.codes.created, requests.codes.accepted]:
        logger.error('Server returned status {0}'.format(r.status_code), section)
        return ProcessResult(
            message='{0}: Failed to post-process - Server returned status {1}'.format(section, r.status_code),
            status_code=1,
        )

    success = False
    queued = False
    started = False
    if section == 'SickBeard':
        if apikey:
            if r.json()['result'] == 'success':
                success = True
        else:
            for line in r.iter_lines():
                if line:
                    line = line.decode('utf-8')
                    logger.postprocess('{0}'.format(line), section)
                    if 'Moving file from' in line:
                        input_name = os.path.split(line)[1]
                    if 'added to the queue' in line:
                        queued = True
                    if 'Processing succeeded' in line or 'Successfully processed' in line:
                        success = True

        if queued:
            time.sleep(60)
    elif section == 'NzbDrone':
        try:
            res = json.loads(r.content)
            scan_id = int(res['id'])
            logger.debug('Scan started with id: {0}'.format(scan_id), section)
            started = True
        except Exception as e:
            logger.warning('No scan id was returned due to: {0}'.format(e), section)
            scan_id = None
            started = False

    if status != 0 and delete_failed and not os.path.dirname(dir_name) == dir_name:
        logger.postprocess('Deleting failed files and folder {0}'.format(dir_name), section)
        remove_dir(dir_name)

    if success:
        return ProcessResult(
            message='{0}: Successfully post-processed {1}'.format(section, input_name),
            status_code=0,
        )
    elif section == 'NzbDrone' and started:
        n = 0
        params = {}
        url = '{0}/{1}'.format(url, scan_id)
        while n < 6:  # set up wait_for minutes to see if command completes..
            time.sleep(10 * wait_for)
            command_status = command_complete(url, params, headers, section)
            if command_status and command_status in ['completed', 'failed']:
                break
            n += 1
        if command_status:
            logger.debug('The Scan command return status: {0}'.format(command_status), section)
        if not os.path.exists(dir_name):
            logger.debug('The directory {0} has been removed. Renaming was successful.'.format(dir_name), section)
            return ProcessResult(
                message='{0}: Successfully post-processed {1}'.format(section, input_name),
                status_code=0,
            )
        elif command_status and command_status in ['completed']:
            logger.debug('The Scan command has completed successfully. Renaming was successful.', section)
            return ProcessResult(
                message='{0}: Successfully post-processed {1}'.format(section, input_name),
                status_code=0,
            )
        elif command_status and command_status in ['failed']:
            logger.debug('The Scan command has failed. Renaming was not successful.', section)
            # return ProcessResult(
            #     message='{0}: Failed to post-process {1}'.format(section, input_name),
            #     status_code=1,
            # )
        if completed_download_handling(url2, headers, section=section):
            logger.debug('The Scan command did not return status completed, but complete Download Handling is enabled. Passing back to {0}.'.format(section), section)
            return ProcessResult(
                message='{0}: Complete DownLoad Handling is enabled. Passing back to {0}'.format(section),
                status_code=status,
            )
        else:
            logger.warning('The Scan command did not return a valid status. Renaming was not successful.', section)
            return ProcessResult(
                message='{0}: Failed to post-process {1}'.format(section, input_name),
                status_code=1,
            )
    else:
        return ProcessResult(
            message='{0}: Failed to post-process - Returned log from {0} was not as expected.'.format(section),
            status_code=1,  # We did not receive Success confirmation.
        )