.data.Xy095a\"\nRE_RSYNC_TEMPFILE = re.compile(r'^\\..*\\.([a-zA-Z0-9_]){6}$')\n\n\ndef _get_filename(fd):\n \"\"\"\n Helper function to get to file name from a file descriptor or filename.\n\n :param fd: file descriptor or filename.\n\n :returns: the filename.\n \"\"\"\n if hasattr(fd, 'name'):\n # fd object\n return fd.name\n\n # fd is a filename\n return fd\n\n\ndef _encode_metadata(metadata):\n \"\"\"\n UTF8 encode any unicode keys or values in given metadata dict.\n\n :param metadata: a dict\n \"\"\"\n def encode_str(item):\n if isinstance(item, six.text_type):\n return item.encode('utf8')\n return item\n\n return dict(((encode_str(k), encode_str(v)) for k, v in metadata.items()))\n\n\ndef read_metadata(fd):\n \"\"\"\n Helper function to read the pickled metadata from an object file.\n\n :param fd: file descriptor or filename to load the metadata from\n\n :returns: dictionary of metadata\n \"\"\"\n metadata = b''\n key = 0\n try:\n while True:\n metadata += xattr.getxattr(fd, '%s%s' % (METADATA_KEY,\n (key or '')))\n key += 1\n except (IOError, OSError) as e:\n for err in 'ENOTSUP', 'EOPNOTSUPP':\n if hasattr(errno, err) and e.errno == getattr(errno, err):\n msg = \"Filesystem at %s does not support xattr\" % \\\n _get_filename(fd)\n logging.exception(msg)\n raise DiskFileXattrNotSupported(e)\n if e.errno == errno.ENOENT:\n raise DiskFileNotExist()\n # TODO: we might want to re-raise errors that don't denote a missing\n # xattr here. Seems to be ENODATA on linux and ENOATTR on BSD/OSX.\n # strings are utf-8 encoded when written, but have not always been\n # (see https://bugs.launchpad.net/swift/+bug/1678018) so encode them again\n # when read\n return _encode_metadata(pickle.loads(metadata))\n\n\ndef write_metadata(fd, metadata, xattr_size=65536):\n \"\"\"\n Helper function to write pickled metadata for an object file.\n\n :param fd: file descriptor or filename to write the metadata\n :param metadata: metadata to write\n \"\"\"\n metastr = pickle.dumps(_encode_metadata(metadata), PICKLE_PROTOCOL)\n key = 0\n while metastr:\n try:\n xattr.setxattr(fd, '%s%s' % (METADATA_KEY, key or ''),\n metastr[:xattr_size])\n metastr = metastr[xattr_size:]\n key += 1\n except IOError as e:\n for err in 'ENOTSUP', 'EOPNOTSUPP':\n if hasattr(errno, err) and e.errno == getattr(errno, err):\n msg = \"Filesystem at %s does not support xattr\" % \\\n _get_filename(fd)\n logging.exception(msg)\n raise DiskFileXattrNotSupported(e)\n if e.errno in (errno.ENOSPC, errno.EDQUOT):\n msg = \"No space left on device for %s\" % _get_filename(fd)\n logging.exception(msg)\n raise DiskFileNoSpace()\n raise\n\n\ndef extract_policy(obj_path):\n \"\"\"\n Extracts the policy for an object (based on the name of the objects\n directory) given the device-relative path to the object. Returns None in\n the event that the path is malformed in some way.\n\n The device-relative path is everything after the mount point; for example:\n\n /srv/node/d42/objects-5/30/179/\n 485dc017205a81df3af616d917c90179/1401811134.873649.data\n\n would have device-relative path:\n\n objects-5/30/179/485dc017205a81df3af616d917c90179/1401811134.873649.data\n\n :param obj_path: device-relative path of an object, or the full path\n :returns: a :class:`~swift.common.storage_policy.BaseStoragePolicy` or None\n \"\"\"\n try:\n obj_portion = obj_path[obj_path.rindex(DATADIR_BASE):]\n obj_dirname = obj_portion[:obj_portion.index('/')]\n except Exception:\n return None\n try:\n base, policy = split_policy_string(obj_dirname)\n except PolicyError:\n return None\n return policy\n\n\ndef quarantine_renamer(device_path, corrupted_file_path):\n \"\"\"\n In the case that a file is corrupted, move it to a quarantined\n area to allow replication to fix it.\n\n :params device_path: The path to the device the corrupted file is on.\n :params corrupted_file_path: The path to the file you want quarantined.\n\n :returns: path (str) of directory the file was moved to\n :raises OSError: re-raises non errno.EEXIST / errno.ENOTEMPTY\n exceptions from rename\n \"\"\"\n policy = extract_policy(corrupted_file_path)\n if policy is None:\n # TODO: support a quarantine-unknown location\n policy = POLICIES.legacy\n from_dir = dirname(corrupted_file_path)\n to_dir = join(device_path, 'quarantined',\n get_data_dir(policy),\n basename(from_dir))\n invalidate_hash(dirname(from_dir))\n try:\n renamer(from_dir, to_dir, fsync=False)\n except OSError as e:\n if e.errno not in (errno.EEXIST, errno.ENOTEMPTY):\n raise\n to_dir = \"%s-%s\" % (to_dir, uuid.uuid4().hex)\n renamer(from_dir, to_dir, fsync=False)\n return to_dir\n\n\ndef read_hashes(partition_dir):\n \"\"\"\n Read the existing hashes.pkl\n\n :returns: a dict, the suffix hashes (if any), the key 'valid' will be False\n if hashes.pkl is corrupt, cannot be read or does not exist\n \"\"\"\n hashes_file = join(partition_dir, HASH_FILE)\n hashes = {'valid': False}\n try:\n with open(hashes_file, 'rb') as hashes_fp:\n pickled_hashes = hashes_fp.read()\n except (IOError, OSError):\n pass\n else:\n try:\n hashes = pickle.loads(pickled_hashes)\n except Exception:\n # pickle.loads() can raise a wide variety of exceptions when\n # given invalid input depending on the way in which the\n # input is invalid.\n pass\n # hashes.pkl w/o valid updated key is \"valid\" but \"forever old\"\n hashes.setdefault('valid', True)\n hashes.setdefault('updated', -1)\n return hashes\n\n\ndef write_hashes(partition_dir, hashes):\n \"\"\"\n Write hashes to hashes.pkl\n\n The updated key is added to hashes before it is written.\n \"\"\"\n hashes_file = join(partition_dir, HASH_FILE)\n # 'valid' key should always be set by the caller; however, if there's a bug\n # setting invalid is most safe\n hashes.setdefault('valid', False)\n hashes['updated'] = time.time()\n write_pickle(hashes, hashes_file, partition_dir, PICKLE_PROTOCOL)\n\n\ndef consolidate_hashes(partition_dir):\n \"\"\"\n Take what's in hashes.pkl and hashes.invalid, combine them, write the\n result back to hashes.pkl, and clear out hashes.invalid.\n\n :param partition_dir: absolute path to partition dir containing hashes.pkl\n and hashes.invalid\n\n :returns: a dict, the suffix hashes (if any), the key 'valid' will be False\n if hashes.pkl is corrupt, cannot be read or does not exist\n \"\"\"\n invalidations_file = join(partition_dir, HASH_INVALIDATIONS_FILE)\n\n with lock_path(partition_dir):\n hashes = read_hashes(partition_dir)\n\n found_invalidation_entry = False\n try:\n with open(invalidations_file, 'rb') as inv_fh:\n for line in inv_fh:\n found_invalidation_entry = True\n suffix = line.strip()\n hashes[suffix] = None\n except (IOError, OSError) as e:\n if e.errno != errno.ENOENT:\n raise\n\n if found_invalidation_entry:\n write_hashes(partition_dir, hashes)\n # Now that all the invalidations are reflected in hashes.pkl, it's\n # safe to clear out the invalidations file.\n with open(invalidations_file, 'wb') as inv_fh:\n pass\n\n return hashes\n\n\ndef invalidate_hash(suffix_dir):\n \"\"\"\n Invalidates the hash for a suffix_dir in the partition's hashes file.\n\n :param suffix_dir: absolute path to suffix dir whose hash needs\n invalidating\n \"\"\"\n\n suffix = basename(suffix_dir)\n partition_dir = dirname(suffix_dir)\n invalidations_file = join(partition_dir, HASH_INVALIDATIONS_FILE)\n with lock_path(partition_dir):\n with open(invalidations_file, 'ab') as inv_fh:\n inv_fh.write(suffix + \"\\n\")\n\n\ndef get_part_path(dev_path, policy, partition):\n \"\"\"\n Given the device path, policy, and partition, returns the full\n path to the partition\n \"\"\"\n return os.path.join(dev_path, get_data_dir(policy), str(partition))\n\n\nclass AuditLocation(object):\n \"\"\"\n Represents an object location to be audited.\n\n Other than being a bucket of data, the only useful thing this does is\n stringify to a filesystem path so the auditor's logs look okay.\n \"\"\"\n\n def __init__(self, path, device, partition, policy):\n self.path, self.device, self.partition, self.policy = (\n path, device, partition, policy)\n\n def __str__(self):\n return str(self.path)\n\n\ndef object_audit_location_generator(devices, mount_check=True, logger=None,\n device_dirs=None, auditor_type=\"ALL\"):\n \"\"\"\n Given a devices path (e.g. \"/srv/node\"), yield an AuditLocation for all\n objects stored under that directory if device_dirs isn't set. If\n device_dirs is set, only yield AuditLocation for the objects under the\n entries in device_dirs. The AuditLocation only knows the path to the hash\n directory, not to the .data file therein (if any). This is to avoid a\n double listdir(hash_dir); the DiskFile object will always do one, so\n we don't.\n\n :param devices: parent directory of the devices to be audited\n :param mount_check: flag to check if a mount check should be performed\n on devices\n :param logger: a logger object\n :param device_dirs: a list of directories under devices to traverse\n :param auditor_type: either ALL or ZBF\n \"\"\"\n if not device_dirs:\n device_dirs = listdir(devices)\n else:\n # remove bogus devices and duplicates from device_dirs\n device_dirs = list(\n set(listdir(devices)).intersection(set(device_dirs)))\n # randomize devices in case of process restart before sweep completed\n shuffle(device_dirs)\n\n for device in device_dirs:\n if mount_check and not \\\n ismount(os.path.join(devices, device)):\n if logger:\n logger.debug(\n _('Skipping %s as it is not mounted'), device)\n continue\n # loop through object dirs for all policies\n device_dir = os.path.join(devices, device)\n try:\n dirs = os.listdir(device_dir)\n except OSError as e:\n if logger:\n logger.debug(\n _('Skipping %(dir)s: %(err)s') % {'dir': device_dir,\n 'err': e.strerror})\n continue\n for dir_ in dirs:\n if not dir_.startswith(DATADIR_BASE):\n continue\n try:\n base, policy = split_policy_string(dir_)\n except PolicyError as e:\n if logger:\n logger.warning(_('Directory %(directory)r does not map '\n 'to a valid policy (%(error)s)') % {\n 'directory': dir_, 'error': e})\n continue\n datadir_path = os.path.join(devices, device, dir_)\n\n partitions = get_auditor_status(datadir_path, logger, auditor_type)\n\n for pos, partition in enumerate(partitions):\n update_auditor_status(datadir_path, logger,\n partitions[pos:], auditor_type)\n part_path = os.path.join(datadir_path, partition)\n try:\n suffixes = listdir(part_path)\n except OSError as e:\n if e.errno != errno.ENOTDIR:\n raise\n continue\n for asuffix in suffixes:\n suff_path = os.path.join(part_path, asuffix)\n try:\n hashes = listdir(suff_path)\n except OSError as e:\n if e.errno != errno.ENOTDIR:\n raise\n continue\n for hsh in hashes:\n hsh_path = os.path.join(suff_path, hsh)\n yield AuditLocation(hsh_path, device, partition,\n policy)\n\n update_auditor_status(datadir_path, logger, [], auditor_type)\n\n\ndef get_auditor_status(datadir_path, logger, auditor_type):\n auditor_status = os.path.join(\n datadir_path, \"auditor_status_%s.json\" % auditor_type)\n status = {}\n try:\n if six.PY3:\n statusfile = open(auditor_status, encoding='utf8')\n else:\n statusfile = open(auditor_status, 'rb')\n with statusfile:\n status = statusfile.read()\n except (OSError, IOError) as e:\n if e.errno != errno.ENOENT and logger:\n logger.warning(_('Cannot read %(auditor_status)s (%(err)s)') %\n {'auditor_status': auditor_status, 'err': e})\n return listdir(datadir_path)\n try:\n status = json.loads(status)\n except ValueError as e:\n logger.warning(_('Loading JSON from %(auditor_status)s failed'\n ' (%(err)s)') %\n {'auditor_status': auditor_status, 'err': e})\n return listdir(datadir_path)\n return status['partitions']\n\n\ndef update_auditor_status(datadir_path, logger, partitions, auditor_type):\n status = json.dumps({'partitions': partitions})\n if six.PY3:\n status = status.encode('utf8')\n auditor_status = os.path.join(\n datadir_path, \"auditor_status_%s.json\" % auditor_type)\n try:\n mtime = os.stat(auditor_status).st_mtime\n except OSError:\n mtime = 0\n recently_updated = (mtime + MIN_TIME_UPDATE_AUDITOR_STATUS) > time.time()\n if recently_updated and len(partitions) > 0:\n if logger:\n logger.debug(\n 'Skipping the update of recently changed %s' % auditor_status)\n return\n try:\n with open(auditor_status, \"wb\") as statusfile:\n statusfile.write(status)\n except (OSError, IOError) as e:\n if logger:\n logger.warning(_('Cannot write %(auditor_status)s (%(err)s)') %\n {'auditor_status': auditor_status, 'err': e})\n\n\ndef clear_auditor_status(devices, auditor_type=\"ALL\"):\n for device in os.listdir(devices):\n for dir_ in os.listdir(os.path.join(devices, device)):\n if not dir_.startswith(\"objects\"):\n continue\n datadir_path = os.path.join(devices, device, dir_)\n auditor_status = os.path.join(\n datadir_path, \"auditor_status_%s.json\" % auditor_type)\n remove_file(auditor_status)\n\n\ndef strip_self(f):\n \"\"\"\n Wrapper to attach module level functions to base class.\n \"\"\"\n def wrapper(self, *args, **kwargs):\n return f(*args, **kwargs)\n return wrapper\n\n\nclass DiskFileRouter(object):\n\n policy_type_to_manager_cls = {}\n\n @classmethod\n def register(cls, policy_type):\n \"\"\"\n Decorator for Storage Policy implementations to register\n their DiskFile implementation.\n \"\"\"\n def register_wrapper(diskfile_cls):\n if policy_type in cls.policy_type_to_manager_cls:\n raise PolicyError(\n '%r is already registered for the policy_type %r' % (\n cls.policy_type_to_manager_cls[policy_type],\n policy_type))\n cls.policy_type_to_manager_cls[policy_type] = diskfile_cls\n return diskfile_cls\n return register_wrapper\n\n def __init__(self, *args, **kwargs):\n self.policy_to_manager = {}\n for policy in POLICIES:\n manager_cls = self.policy_type_to_manager_cls[policy.policy_type]\n self.policy_to_manager[policy] = manager_cls(*args, **kwargs)\n\n def __getitem__(self, policy):\n return self.policy_to_manager[policy]\n\n\nclass BaseDiskFileManager(object):\n \"\"\"\n Management class for devices, providing common place for shared parameters\n and methods not provided by the DiskFile class (which primarily services\n the object server REST API layer).\n\n The `get_diskfile()` method is how this implementation creates a `DiskFile`\n object.\n\n .. note::\n\n This class is reference implementation specific and not part of the\n pluggable on-disk backend API.\n\n .. note::\n\n TODO(portante): Not sure what the right name to recommend here, as\n \"manager\" seemed generic enough, though suggestions are welcome.\n\n :param conf: caller provided configuration object\n :param logger: caller provided logger\n \"\"\"\n\n diskfile_cls = None # must be set by subclasses\n\n invalidate_hash = strip_self(invalidate_hash)\n consolidate_hashes = strip_self(consolidate_hashes)\n quarantine_renamer = strip_self(quarantine_renamer)\n\n def __init__(self, conf, logger):\n self.logger = logger\n self.devices = conf.get('devices', '/srv/node')\n self.disk_chunk_size = int(conf.get('disk_chunk_size', 65536))\n self.keep_cache_size = int(conf.get('keep_cache_size', 5242880))\n self.bytes_per_sync = int(conf.get('mb_per_sync', 512)) * 1024 * 1024\n self.mount_check = config_true_value(conf.get('mount_check', 'true'))\n self.reclaim_age = int(conf.get('reclaim_age', DEFAULT_RECLAIM_AGE))\n self.replication_one_per_device = config_true_value(\n conf.get('replication_one_per_device', 'true'))\n self.replication_lock_timeout = int(conf.get(\n 'replication_lock_timeout', 15))\n\n self.use_splice = False\n self.pipe_size = None\n\n conf_wants_splice = config_true_value(conf.get('splice', 'no'))\n # If the operator wants zero-copy with splice() but we don't have the\n # requisite kernel support, complain so they can go fix it.\n if conf_wants_splice and not splice.available:\n self.logger.warning(\n \"Use of splice() requested (config says \\\"splice = %s\\\"), \"\n \"but the system does not support it. \"\n \"splice() will not be used.\" % conf.get('splice'))\n elif conf_wants_splice and splice.available:\n try:\n sockfd = get_md5_socket()\n os.close(sockfd)\n except IOError as err:\n # AF_ALG socket support was introduced in kernel 2.6.38; on\n # systems with older kernels (or custom-built kernels lacking\n # AF_ALG support), we can't use zero-copy.\n if err.errno != errno.EAFNOSUPPORT:\n raise\n self.logger.warning(\"MD5 sockets not supported. \"\n \"splice() will not be used.\")\n else:\n self.use_splice = True\n with open('/proc/sys/fs/pipe-max-size') as f:\n max_pipe_size = int(f.read())\n self.pipe_size = min(max_pipe_size, self.disk_chunk_size)\n self.use_linkat = o_tmpfile_supported()\n\n def make_on_disk_filename(self, timestamp, ext=None,\n ctype_timestamp=None, *a, **kw):\n \"\"\"\n Returns filename for given timestamp.\n\n :param timestamp: the object timestamp, an instance of\n :class:`~swift.common.utils.Timestamp`\n :param ext: an optional string representing a file extension to be\n appended to the returned file name\n :param ctype_timestamp: an optional content-type timestamp, an instance\n of :class:`~swift.common.utils.Timestamp`\n :returns: a file name\n \"\"\"\n rv = timestamp.internal\n if ext == '.meta' and ctype_timestamp:\n # If ctype_timestamp is None then the filename is simply the\n # internal form of the timestamp. If ctype_timestamp is not None\n # then the difference between the raw values of the two timestamps\n # is appended as a hex number, with its sign.\n #\n # There are two reasons for encoding the content-type timestamp\n # in the filename in this way. First, it means that two .meta files\n # having the same timestamp but different content-type timestamps\n # (and potentially different content-type values) will be distinct\n # and therefore will be independently replicated when rsync\n # replication is used. That ensures that all nodes end up having\n # all content-type values after replication (with the most recent\n # value being selected when the diskfile is opened). Second, having\n # the content-type encoded in timestamp in the filename makes it\n # possible for the on disk file search code to determine that\n # timestamp by inspecting only the filename, and not needing to\n # open the file and read its xattrs.\n rv = encode_timestamps(timestamp, ctype_timestamp, explicit=True)\n if ext:\n rv = '%s%s' % (rv, ext)\n return rv\n\n def parse_on_disk_filename(self, filename):\n \"\"\"\n Parse an on disk file name.\n\n :param filename: the file name including extension\n :returns: a dict, with keys for timestamp, ext and ctype_timestamp:\n\n * timestamp is a :class:`~swift.common.utils.Timestamp`\n * ctype_timestamp is a :class:`~swift.common.utils.Timestamp` or\n None for .meta files, otherwise None\n * ext is a string, the file extension including the leading dot or\n the empty string if the filename has no extension.\n\n Subclasses may override this method to add further keys to the\n returned dict.\n\n :raises DiskFileError: if any part of the filename is not able to be\n validated.\n \"\"\"\n ts_ctype = None\n fname, ext = splitext(filename)\n try:\n if ext == '.meta':\n timestamp, ts_ctype = decode_timestamps(\n fname, explicit=True)[:2]\n else:\n timestamp = Timestamp(fname)\n except ValueError:\n raise DiskFileError('Invalid Timestamp value in filename %r'\n % filename)\n return {\n 'timestamp': timestamp,\n 'ext': ext,\n 'ctype_timestamp': ts_ctype\n }\n\n def _process_ondisk_files(self, exts, results, **kwargs):\n \"\"\"\n Called by get_ondisk_files(). Should be over-ridden to implement\n subclass specific handling of files.\n\n :param exts: dict of lists of file info, keyed by extension\n :param results: a dict that may be updated with results\n \"\"\"\n raise NotImplementedError\n\n def _verify_ondisk_files(self, results, **kwargs):\n \"\"\"\n Verify that the final combination of on disk files complies with the\n diskfile contract.\n\n :param results: files that have been found and accepted\n :returns: True if the file combination is compliant, False otherwise\n \"\"\"\n data_file, meta_file, ts_file = tuple(\n [results[key]\n for key in ('data_file', 'meta_file', 'ts_file')])\n\n return ((data_file is None and meta_file is None and ts_file is None)\n or (ts_file is not None and data_file is None\n and meta_file is None)\n or (data_file is not None and ts_file is None))\n\n def _split_list(self, original_list, condition):\n \"\"\"\n Split a list into two lists. The first list contains the first N items\n of the original list, in their original order, where 0 < N <=\n len(original list). The second list contains the remaining items of the\n original list, in their original order.\n\n The index, N, at which the original list is split is the index of the\n first item in the list that does not satisfy the given condition. Note\n that the original list should be appropriately sorted if the second\n list is to contain no items that satisfy the given condition.\n\n :param original_list: the list to be split.\n :param condition: a single argument function that will be used to test\n for the list item to split on.\n :return: a tuple of two lists.\n \"\"\"\n for i, item in enumerate(original_list):\n if not condition(item):\n return original_list[:i], original_list[i:]\n return original_list, []\n\n def _split_gt_timestamp(self, file_info_list, timestamp):\n \"\"\"\n Given a list of file info dicts, reverse sorted by timestamp, split the\n list into two: items newer than timestamp, and items at same time or\n older than timestamp.\n\n :param file_info_list: a list of file_info dicts.\n :param timestamp: a Timestamp.\n :return: a tuple of two lists.\n \"\"\"\n return self._split_list(\n file_info_list, lambda x: x['timestamp'] > timestamp)\n\n def _split_gte_timestamp(self, file_info_list, timestamp):\n \"\"\"\n Given a list of file info dicts, reverse sorted by timestamp, split the\n list into two: items newer than or at same time as the timestamp, and\n items older than timestamp.\n\n :param file_info_list: a list of file_info dicts.\n :param timestamp: a Timestamp.\n :return: a tuple of two lists.\n \"\"\"\n return self._split_list(\n file_info_list, lambda x: x['timestamp'] >= timestamp)\n\n def get_ondisk_files(self, files, datadir, verify=True, **kwargs):\n \"\"\"\n Given a simple list of files names, determine the files that constitute\n a valid fileset i.e. a set of files that defines the state of an\n object, and determine the files that are obsolete and could be deleted.\n Note that some files may fall into neither category.\n\n If a file is considered part of a valid fileset then its info dict will\n be added to the results dict, keyed by <extension>_info. Any files that\n are no longer required will have their info dicts added to a list\n stored under the key 'obsolete'.\n\n The results dict will always contain entries with keys 'ts_file',\n 'data_file' and 'meta_file'. Their values will be the fully qualified\n path to a file of the corresponding type if there is such a file in the\n valid fileset, or None.\n\n :param files: a list of file names.\n :param datadir: directory name files are from.\n :param verify: if True verify that the ondisk file contract has not\n been violated, otherwise do not verify.\n :returns: a dict that will contain keys:\n ts_file -> path to a .ts file or None\n data_file -> path to a .data file or None\n meta_file -> path to a .meta file or None\n ctype_file -> path to a .meta file or None\n and may contain keys:\n ts_info -> a file info dict for a .ts file\n data_info -> a file info dict for a .data file\n meta_info -> a file info dict for a .meta file\n ctype_info -> a file info dict for a .meta file which\n contains the content-type value\n unexpected -> a list of file paths for unexpected\n files\n possible_reclaim -> a list of file info dicts for possible\n reclaimable files\n obsolete -> a list of file info dicts for obsolete files\n \"\"\"\n # Build the exts data structure:\n # exts is a dict that maps file extensions to a list of file_info\n # dicts for the files having that extension. The file_info dicts are of\n # the form returned by parse_on_disk_filename, with the filename added.\n # Each list is sorted in reverse timestamp order.\n\n # the results dict is used to collect results of file filtering\n results = {}\n\n # The exts dict will be modified during subsequent processing as files\n # are removed to be discarded or ignored.\n exts = defaultdict(list)\n\n for afile in files:\n # Categorize files by extension\n try:\n file_info = self.parse_on_disk_filename(afile)\n file_info['filename'] = afile\n exts[file_info['ext']].append(file_info)\n except DiskFileError as e:\n file_path = os.path.join(datadir or '', afile)\n results.setdefault('unexpected', []).append(file_path)\n # log warnings if it's not a rsync temp file\n if RE_RSYNC_TEMPFILE.match(afile):\n self.logger.debug('Rsync tempfile: %s', file_path)\n else:\n self.logger.warning('Unexpected file %s: %s',\n file_path, e)\n for ext in exts:\n # For each extension sort files into reverse chronological order.\n exts[ext] = sorted(\n exts[ext], key=lambda info: info['timestamp'], reverse=True)\n\n if exts.get('.ts'):\n # non-tombstones older than or equal to latest tombstone are\n # obsolete\n for ext in filter(lambda ext: ext != '.ts', exts.keys()):\n exts[ext], older = self._split_gt_timestamp(\n exts[ext], exts['.ts'][0]['timestamp'])\n results.setdefault('obsolete', []).extend(older)\n # all but most recent .ts are obsolete\n results.setdefault('obsolete', []).extend(exts['.ts'][1:])\n exts['.ts'] = exts['.ts'][:1]\n\n if exts.get('.meta'):\n # retain the newest meta file\n retain = 1\n if exts['.meta'][1:]:\n # there are other meta files so find the one with newest\n # ctype_timestamp...\n exts['.meta'][1:] = sorted(\n exts['.meta'][1:],\n key=lambda info: info['ctype_timestamp'],\n reverse=True)\n # ...and retain this IFF its ctype_timestamp is greater than\n # newest meta file\n if (exts['.meta'][1]['ctype_timestamp'] >\n exts['.meta'][0]['ctype_timestamp']):\n if (exts['.meta'][1]['timestamp'] ==\n exts['.meta'][0]['timestamp']):\n # both at same timestamp so retain only the one with\n # newest ctype\n exts['.meta'][:2] = [exts['.meta'][1],\n exts['.meta'][0]]\n retain = 1\n else:\n # retain both - first has newest metadata, second has\n # newest ctype\n retain = 2\n # discard all meta files not being retained...\n results.setdefault('obsolete', []).extend(exts['.meta'][retain:])\n exts['.meta'] = exts['.meta'][:retain]\n\n # delegate to subclass handler\n self._process_ondisk_files(exts, results, **kwargs)\n\n # set final choice of files\n if 'data_info' in results:\n if exts.get('.meta'):\n # only report a meta file if a data file has been chosen\n results['meta_info'] = exts['.meta'][0]\n ctype_info = exts['.meta'].pop()\n if (ctype_info['ctype_timestamp']\n > results['data_info']['timestamp']):\n results['ctype_info'] = ctype_info\n elif exts.get('.ts'):\n # only report a ts file if a data file has not been chosen\n # (ts files will commonly already have been removed from exts if\n # a data file was chosen, but that may not be the case if\n # non-durable EC fragment(s) were chosen, hence the elif here)\n results['ts_info'] = exts['.ts'][0]\n\n # set ts_file, data_file, meta_file and ctype_file with path to\n # chosen file or None\n for info_key in ('data_info', 'meta_info', 'ts_info', 'ctype_info'):\n info = results.get(info_key)\n key = info_key[:-5] + '_file'\n results[key] = join(datadir, info['filename']) if info else None\n\n if verify:\n assert self._verify_ondisk_files(\n results, **kwargs), \\\n \"On-disk file search algorithm contract is broken: %s\" \\\n % str(results)\n\n return results\n\n def cleanup_ondisk_files(self, hsh_path, **kwargs):\n \"\"\"\n Clean up on-disk files that are obsolete and gather the set of valid\n on-disk files for an object.\n\n :param hsh_path: object hash path\n :param frag_index: if set, search for a specific fragment index .data\n file, otherwise accept the first valid .data file\n :returns: a dict that may contain: valid on disk files keyed by their\n filename extension; a list of obsolete files stored under the\n key 'obsolete'; a list of files remaining in the directory,\n reverse sorted, stored under the key 'files'.\n \"\"\"\n def is_reclaimable(timestamp):\n return (time.time() - float(timestamp)) > self.reclaim_age\n\n files = listdir(hsh_path)\n files.sort(reverse=True)\n results = self.get_ondisk_files(\n files, hsh_path, verify=False, **kwargs)\n if 'ts_info' in results and is_reclaimable(\n results['ts_info']['timestamp']):\n remove_file(join(hsh_path, results['ts_info']['filename']))\n files.remove(results.pop('ts_info')['filename'])\n for file_info in results.get('possible_reclaim', []):\n # stray files are not deleted until reclaim-age\n if is_reclaimable(file_info['timestamp']):\n results.setdefault('obsolete', []).append(file_info)\n for file_info in results.get('obsolete', []):\n remove_file(join(hsh_path, file_info['filename']))\n files.remove(file_info['filename'])\n results['files'] = files\n return results\n\n def _update_suffix_hashes(self, hashes, ondisk_info):\n \"\"\"\n Applies policy specific updates to the given dict of md5 hashes for\n the given ondisk_info.\n\n :param hashes: a dict of md5 hashes to be updated\n :param ondisk_info: a dict describing the state of ondisk files, as\n returned by get_ondisk_files\n \"\"\"\n raise NotImplementedError\n\n def _hash_suffix_dir(self, path):\n \"\"\"\n\n :param path: full path to directory\n \"\"\"\n hashes = defaultdict(hashlib.md5)\n try:\n path_contents = sorted(os.listdir(path))\n except OSError as err:\n if err.errno in (errno.ENOTDIR, errno.ENOENT):\n raise PathNotDir()\n raise\n for hsh in path_contents:\n hsh_path = join(path, hsh)\n try:\n ondisk_info = self.cleanup_ondisk_files(hsh_path)\n except OSError as err:\n if err.errno == errno.ENOTDIR:\n partition_path = dirname(path)\n objects_path = dirname(partition_path)\n device_path = dirname(objects_path)\n quar_path = quarantine_renamer(device_path, hsh_path)\n logging.exception(\n _('Quarantined %(hsh_path)s to %(quar_path)s because '\n 'it is not a directory'), {'hsh_path': hsh_path,\n 'quar_path': quar_path})\n continue\n raise\n if not ondisk_info['files']:\n try:\n os.rmdir(hsh_path)\n except OSError:\n pass\n continue\n\n # ondisk_info has info dicts containing timestamps for those\n # files that could determine the state of the diskfile if it were\n # to be opened. We update the suffix hash with the concatenation of\n # each file's timestamp and extension. The extension is added to\n # guarantee distinct hash values from two object dirs that have\n # different file types at the same timestamp(s).\n #\n # Files that may be in the object dir but would have no effect on\n # the state of the diskfile are not used to update the hash.\n for key in (k for k in ('meta_info', 'ts_info')\n if k in ondisk_info):\n info = ondisk_info[key]\n hashes[None].update(info['timestamp'].internal + info['ext'])\n\n # delegate to subclass for data file related updates...\n self._update_suffix_hashes(hashes, ondisk_info)\n\n if 'ctype_info' in ondisk_info:\n # We have a distinct content-type timestamp so update the\n # hash. As a precaution, append '_ctype' to differentiate this\n # value from any other timestamp value that might included in\n # the hash in future. There is no .ctype file so use _ctype to\n # avoid any confusion.\n info = ondisk_info['ctype_info']\n hashes[None].update(info['ctype_timestamp'].internal\n + '_ctype')\n\n try:\n os.rmdir(path)\n except OSError as e:\n if e.errno == errno.ENOENT:\n raise PathNotDir()\n else:\n # if we remove it, pretend like it wasn't there to begin with so\n # that the suffix key gets removed\n raise PathNotDir()\n return hashes\n\n def _hash_suffix(self, path):\n \"\"\"\n Performs reclamation and returns an md5 of all (remaining) files.\n\n :param path: full path to directory\n :raises PathNotDir: if given path is not a valid directory\n :raises OSError: for non-ENOTDIR errors\n \"\"\"\n raise NotImplementedError\n\n def _get_hashes(self, *args, **kwargs):\n hashed, hashes = self.__get_hashes(*args, **kwargs)\n hashes.pop('updated', None)\n hashes.pop('valid', None)\n return hashed, hashes\n\n def __get_hashes(self, device, partition, policy, recalculate=None,\n do_listdir=False):\n \"\"\"\n Get hashes for each suffix dir in a partition. do_listdir causes it to\n mistrust the hash cache for suffix existence at the (unexpectedly high)\n cost of a listdir.\n\n :param device: name of target device\n :param partition: partition on the device in which the object lives\n :param policy: the StoragePolicy instance\n :param recalculate: list of suffixes which should be recalculated when\n got\n :param do_listdir: force existence check for all hashes in the\n partition\n\n :returns: tuple of (number of suffix dirs hashed, dictionary of hashes)\n \"\"\"\n hashed = 0\n dev_path = self.get_dev_path(device)\n partition_path = get_part_path(dev_path, policy, partition)\n hashes_file = join(partition_path, HASH_FILE)\n modified = False\n orig_hashes = {'valid': False}\n\n if recalculate is None:\n recalculate = []\n\n try:\n orig_hashes = self.consolidate_hashes(partition_path)\n except Exception:\n self.logger.warning('Unable to read %r', hashes_file,\n exc_info=True)\n\n if not orig_hashes['valid']:\n # This is the only path to a valid hashes from invalid read (e.g.\n # does not exist, corrupt, etc.). Moreover, in order to write this\n # valid hashes we must read *the exact same* invalid state or we'll\n # trigger race detection.\n do_listdir = True\n hashes = {'valid': True}\n # If the exception handling around consolidate_hashes fired we're\n # going to do a full rehash regardless; but we need to avoid\n # needless recursion if the on-disk hashes.pkl is actually readable\n # (worst case is consolidate_hashes keeps raising exceptions and we\n # eventually run out of stack).\n # N.B. orig_hashes invalid only effects new parts and error/edge\n # conditions - so try not to get overly caught up trying to\n # optimize it out unless you manage to convince yourself there's a\n # bad behavior.\n orig_hashes = read_hashes(partition_path)\n else:\n hashes = copy.deepcopy(orig_hashes)\n\n if do_listdir:\n for suff in os.listdir(partition_path):\n if len(suff) == 3:\n hashes.setdefault(suff, None)\n modified = True\n self.logger.debug('Run listdir on %s', partition_path)\n hashes.update((suffix, None) for suffix in recalculate)\n for suffix, hash_ in hashes.items():\n if not hash_:\n suffix_dir = join(partition_path, suffix)\n try:\n hashes[suffix] = self._hash_suffix(suffix_dir)\n hashed += 1\n except PathNotDir:\n del hashes[suffix]\n except OSError:\n logging.exception(_('Error hashing suffix'))\n modified = True\n if modified:\n with lock_path(partition_path):\n if read_hashes(partition_path) == orig_hashes:\n write_hashes(partition_path, hashes)\n return hashed, hashes\n return self.__get_hashes(device, partition, policy,\n recalculate=recalculate,\n do_listdir=do_listdir)\n else:\n return hashed, hashes\n\n def construct_dev_path(self, device):\n \"\"\"\n Construct the path to a device without checking if it is mounted.\n\n :param device: name of target device\n :returns: full path to the device\n \"\"\"\n return os.path.join(self.devices, device)\n\n def get_dev_path(self, device, mount_check=None):\n \"\"\"\n Return the path to a device, first checking to see if either it\n is a proper mount point, or at least a directory depending on\n the mount_check configuration option.\n\n :param device: name of target device\n :param mount_check: whether or not to check mountedness of device.\n Defaults to bool(self.mount_check).\n :returns: full path to the device, None if the path to the device is\n not a proper mount point or directory.\n \"\"\"\n # we'll do some kind of check unless explicitly forbidden\n if mount_check is not False:\n if mount_check or self.mount_check:\n check = check_mount\n else:\n check = check_dir\n if not check(self.devices, device):\n return None\n return os.path.join(self.devices, device)\n\n @contextmanager\n def replication_lock(self, device):\n \"\"\"\n A context manager that will lock on the device given, if\n configured to do so.\n\n :param device: name of target device\n :raises ReplicationLockTimeout: If the lock on the device\n cannot be granted within the configured timeout.\n \"\"\"\n if self.replication_one_per_device:\n dev_path = self.get_dev_path(device)\n with lock_path(\n dev_path,\n timeout=self.replication_lock_timeout,\n timeout_class=ReplicationLockTimeout):\n yield True\n else:\n yield True\n\n def pickle_async_update(self, device, account, container, obj, data,\n timestamp, policy):\n \"\"\"\n Write data describing a container update notification to a pickle file\n in the async_pending directory.\n\n :param device: name of target device\n :param account: account name for the object\n :param container: container name for the object\n :param obj: object name for the object\n :param data: update data to be written to pickle file\n :param timestamp: a Timestamp\n :param policy: the StoragePolicy instance\n \"\"\"\n device_path = self.construct_dev_path(device)\n async_dir = os.path.join(device_path, get_async_dir(policy))\n tmp_dir = os.path.join(device_path, get_tmp_dir(policy))\n mkdirs(tmp_dir)\n ohash = hash_path(account, container, obj)\n write_pickle(\n data,\n os.path.join(async_dir, ohash[-3:], ohash + '-' +\n Timestamp(timestamp).internal),\n tmp_dir)\n self.logger.increment('async_pendings')\n\n def get_diskfile(self, device, partition, account, container, obj,\n policy, **kwargs):\n \"\"\"\n Returns a BaseDiskFile instance for an object based on the object's\n partition, path parts and policy.\n\n :param device: name of target device\n :param partition: partition on device in which the object lives\n :param account: account name for the object\n :param container: container name for the object\n :param obj: object name for the object\n :param policy: the StoragePolicy instance\n \"\"\"\n dev_path = self.get_dev_path(device)\n if not dev_path:\n raise DiskFileDeviceUnavailable()\n return self.diskfile_cls(self, dev_path,\n partition, account, container, obj,\n policy=policy, use_splice=self.use_splice,\n pipe_size=self.pipe_size,\n use_linkat=self.use_linkat, **kwargs)\n\n def object_audit_location_generator(self, device_dirs=None,\n auditor_type=\"ALL\"):\n \"\"\"\n Yield an AuditLocation for all objects stored under device_dirs.\n\n :param device_dirs: directory of target device\n :param auditor_type: either ALL or ZBF\n \"\"\"\n return object_audit_location_generator(self.devices, self.mount_check,\n self.logger, device_dirs,\n auditor_type)\n\n def get_diskfile_from_audit_location(self, audit_location):\n \"\"\"\n Returns a BaseDiskFile instance for an object at the given\n AuditLocation.\n\n :param audit_location: object location to be audited\n \"\"\"\n dev_path = self.get_dev_path(audit_location.device, mount_check=False)\n return self.diskfile_cls.from_hash_dir(\n self, audit_location.path, dev_path,\n audit_location.partition, policy=audit_location.policy)\n\n def get_diskfile_from_hash(self, device, partition, object_hash,\n policy, **kwargs):\n \"\"\"\n Returns a DiskFile instance for an object at the given\n object_hash. Just in case someone thinks of refactoring, be\n sure DiskFileDeleted is *not* raised, but the DiskFile\n instance representing the tombstoned object is returned\n instead.\n\n :param device: name of target device\n :param partition: partition on the device in which the object lives\n :param object_hash: the hash of an object path\n :param policy: the StoragePolicy instance\n :raises DiskFileNotExist: if the object does not exist\n :returns: an instance of BaseDiskFile\n \"\"\"\n dev_path = self.get_dev_path(device)\n if not dev_path:\n raise DiskFileDeviceUnavailable()\n object_path = os.path.join(\n dev_path, get_data_dir(policy), str(partition), object_hash[-3:],\n object_hash)\n try:\n filenames = self.cleanup_ondisk_files(object_path)['files']\n except OSError as err:\n if err.errno == errno.ENOTDIR:\n quar_path = self.quarantine_renamer(dev_path, object_path)\n logging.exception(\n _('Quarantined %(object_path)s to %(quar_path)s because '\n 'it is not a directory'), {'object_path': object_path,\n 'quar_path': quar_path})\n raise DiskFileNotExist()\n if err.errno != errno.ENOENT:\n raise\n raise DiskFileNotExist()\n if not filenames:\n raise DiskFileNotExist()\n try:\n metadata = read_metadata(os.path.join(object_path, filenames[-1]))\n except EOFError:\n raise DiskFileNotExist()\n try:\n account, container, obj = split_path(\n metadata.get('name', ''), 3, 3, True)\n except ValueError:\n raise DiskFileNotExist()\n return self.diskfile_cls(self, dev_path,\n partition, account, container, obj,\n policy=policy, **kwargs)\n\n def get_hashes(self, device, partition, suffixes, policy):\n \"\"\"\n\n :param device: name of target device\n :param partition: partition name\n :param suffixes: a list of suffix directories to be recalculated\n :param policy: the StoragePolicy instance\n :returns: a dictionary that maps suffix directories\n \"\"\"\n dev_path = self.get_dev_path(device)\n if not dev_path:\n raise DiskFileDeviceUnavailable()\n partition_path = get_part_path(dev_path, policy, partition)\n if not os.path.exists(partition_path):\n mkdirs(partition_path)\n _junk, hashes = tpool_reraise(\n self._get_hashes, device, partition, policy, recalculate=suffixes)\n return hashes\n\n def _listdir(self, path):\n \"\"\"\n :param path: full path to directory\n \"\"\"\n try:\n return os.listdir(path)\n except OSError as err:\n if err.errno != errno.ENOENT:\n self.logger.error(\n 'ERROR: Skipping %r due to error with listdir attempt: %s',\n path, err)\n return []\n\n def yield_suffixes(self, device, partition, policy):\n \"\"\"\n Yields tuples of (full_path, suffix_only) for suffixes stored\n on the given device and partition.\n\n :param device: name of target device\n :param partition: partition name\n :param policy: the StoragePolicy instance\n \"\"\"\n dev_path = self.get_dev_path(device)\n if not dev_path:\n raise DiskFileDeviceUnavailable()\n partition_path = get_part_path(dev_path, policy, partition)\n for suffix in self._listdir(partition_path):\n if len(suffix) != 3:\n continue\n try:\n int(suffix, 16)\n except ValueError:\n continue\n yield (os.path.join(partition_path, suffix), suffix)\n\n def yield_hashes(self, device, partition, policy,\n suffixes=None, **kwargs):\n \"\"\"\n Yields tuples of (hash_only, timestamps) for object\n information stored for the given device, partition, and\n (optionally) suffixes. If suffixes is None, all stored\n suffixes will be searched for object hashes. Note that if\n suffixes is not None but empty, such as [], then nothing will\n be yielded.\n\n timestamps is a dict which may contain items mapping:\n\n - ts_data -> timestamp of data or tombstone file,\n - ts_meta -> timestamp of meta file, if one exists\n - ts_ctype -> timestamp of meta file containing most recent\n content-type value, if one exists\n\n where timestamps are instances of\n :class:`~swift.common.utils.Timestamp`\n\n :param device: name of target device\n :param partition: partition name\n :param policy: the StoragePolicy instance\n :param suffixes: optional list of suffix directories to be searched\n \"\"\"\n dev_path = self.get_dev_path(device)\n if not dev_path:\n raise DiskFileDeviceUnavailable()\n if suffixes is None:\n suffixes = self.yield_suffixes(device, partition, policy)\n else:\n partition_path = get_part_path(dev_path, policy, partition)\n suffixes = (\n (os.path.join(partition_path, suffix), suffix)\n for suffix in suffixes)\n key_preference = (\n ('ts_meta', 'meta_info', 'timestamp'),\n ('ts_data', 'data_info', 'timestamp'),\n ('ts_data', 'ts_info', 'timestamp'),\n ('ts_ctype', 'ctype_info', 'ctype_timestamp'),\n )\n for suffix_path, suffix in suffixes:\n for object_hash in self._listdir(suffix_path):\n object_path = os.path.join(suffix_path, object_hash)\n try:\n results = self.cleanup_ondisk_files(\n object_path, **kwargs)\n timestamps = {}\n for ts_key, info_key, info_ts_key in key_preference:\n if info_key not in results:\n continue\n timestamps[ts_key] = results[info_key][info_ts_key]\n if 'ts_data' not in timestamps:\n # file sets that do not include a .data or .ts\n # file cannot be opened and therefore cannot\n # be ssync'd\n continue\n yield (object_hash, timestamps)\n except AssertionError as err:\n self.logger.debug('Invalid file set in %s (%s)' % (\n object_path, err))\n except DiskFileError as err:\n self.logger.debug(\n 'Invalid diskfile filename in %r (%s)' % (\n object_path, err))\n\n\nclass BaseDiskFileWriter(object):\n \"\"\"\n Encapsulation of the write context for servicing PUT REST API\n requests. Serves as the context manager object for the\n :class:`swift.obj.diskfile.DiskFile` class's\n :func:`swift.obj.diskfile.DiskFile.create` method.\n\n .. note::\n\n It is the responsibility of the\n :func:`swift.obj.diskfile.DiskFile.create` method context manager to\n close the open file descriptor.\n\n .. note::\n\n The arguments to the constructor are considered implementation\n specific. The API does not define the constructor arguments.\n\n :param name: name of object from REST API\n :param datadir: on-disk directory object will end up in on\n :func:`swift.obj.diskfile.DiskFileWriter.put`\n :param fd: open file descriptor of temporary file to receive data\n :param tmppath: full path name of the opened file descriptor\n :param bytes_per_sync: number bytes written between sync calls\n :param diskfile: the diskfile creating this DiskFileWriter instance\n \"\"\"\n\n def __init__(self, name, datadir, fd, tmppath, bytes_per_sync, diskfile):\n # Parameter tracking\n self._name = name\n self._datadir = datadir\n self._fd = fd\n self._tmppath = tmppath\n self._bytes_per_sync = bytes_per_sync\n self._diskfile = diskfile\n\n # Internal attributes\n self._upload_size = 0\n self._last_sync = 0\n self._extension = '.data'\n self._put_succeeded = False\n\n @property\n def manager(self):\n return self._diskfile.manager\n\n @property\n def put_succeeded(self):\n return self._put_succeeded\n\n def write(self, chunk):\n \"\"\"\n Write a chunk of data to disk. All invocations of this method must\n come before invoking the :func:\n\n For this implementation, the data is written into a temporary file.\n\n :param chunk: the chunk of data to write as a string object\n\n :returns: the total number of bytes written to an object\n \"\"\"\n\n while chunk:\n written = os.write(self._fd, chunk)\n self._upload_size += written\n chunk = chunk[written:]\n\n # For large files sync every 512MB (by default) written\n diff = self._upload_size - self._last_sync\n if diff >= self._bytes_per_sync:\n tpool_reraise(fdatasync, self._fd)\n drop_buffer_cache(self._fd, self._last_sync, diff)\n self._last_sync = self._upload_size\n\n return self._upload_size\n\n def _finalize_put(self, metadata, target_path, cleanup):\n # Write the metadata before calling fsync() so that both data and\n # metadata are flushed to disk.\n write_metadata(self._fd, metadata)\n # We call fsync() before calling drop_cache() to lower the amount of\n # redundant work the drop cache code will perform on the pages (now\n # that after fsync the pages will be all clean).\n fsync(self._fd)\n # From the Department of the Redundancy Department, make sure we call\n # drop_cache() after fsync() to avoid redundant work (pages all\n # clean).\n drop_buffer_cache(self._fd, 0, self._upload_size)\n self.manager.invalidate_hash(dirname(self._datadir))\n # After the rename/linkat completes, this object will be available for\n # requests to reference.\n if self._tmppath:\n # It was a named temp file created by mkstemp()\n renamer(self._tmppath, target_path)\n else:\n # It was an unnamed temp file created by open() with O_TMPFILE\n link_fd_to_path(self._fd, target_path,\n self._diskfile._dirs_created)\n # If rename is successful, flag put as succeeded. This is done to avoid\n # unnecessary os.unlink() of tempfile later. As renamer() has\n # succeeded, the tempfile would no longer exist at its original path.\n self._put_succeeded = True\n if cleanup:\n try:\n self.manager.cleanup_ondisk_files(self._datadir)\n except OSError:\n logging.exception(_('Problem cleaning up %s'), self._datadir)\n\n def _put(self, metadata, cleanup=True, *a, **kw):\n \"\"\"\n Helper method for subclasses.\n\n For this implementation, this method is responsible for renaming the\n temporary file to the final name and directory location. This method\n should be called after the final call to\n :func:`swift.obj.diskfile.DiskFileWriter.write`.\n\n :param metadata: dictionary of metadata to be associated with the\n object\n :param cleanup: a Boolean. If True then obsolete files will be removed\n from the object dir after the put completes, otherwise\n obsolete files are left in place.\n \"\"\"\n timestamp = Timestamp(metadata['X-Timestamp'])\n ctype_timestamp = metadata.get('Content-Type-Timestamp')\n if ctype_timestamp:\n ctype_timestamp = Timestamp(ctype_timestamp)\n filename = self.manager.make_on_disk_filename(\n timestamp, self._extension, ctype_timestamp=ctype_timestamp,\n *a, **kw)\n metadata['name'] = self._name\n target_path = join(self._datadir, filename)\n\n tpool_reraise(self._finalize_put, metadata, target_path, cleanup)\n\n def put(self, metadata):\n \"\"\"\n Finalize writing the file on disk.\n\n :param metadata: dictionary of metadata to be associated with the\n object\n \"\"\"\n raise NotImplementedError\n\n def commit(self, timestamp):\n \"\"\"\n Perform any operations necessary to mark the object as durable. For\n replication policy type this is a no-op.\n\n :param timestamp: object put timestamp, an instance of\n :class:`~swift.common.utils.Timestamp`\n \"\"\"\n pass\n\n\nclass BaseDiskFileReader(object):\n \"\"\"\n Encapsulation of the WSGI read context for servicing GET REST API\n requests. Serves as the context manager object for the\n :class:`swift.obj.diskfile.DiskFile` class's\n :func:`swift.obj.diskfile.DiskFile.reader` method.\n\n .. note::\n\n The quarantining behavior of this method is considered implementation\n specific, and is not required of the API.\n\n .. note::\n\n The arguments to the constructor are considered implementation\n specific. The API does not define the constructor arguments.\n\n :param fp: open file object pointer reference\n :param data_file: on-disk data file name for the object\n :param obj_size: verified on-disk size of the object\n :param etag: expected metadata etag value for entire file\n :param disk_chunk_size: size of reads from disk in bytes\n :param keep_cache_size: maximum object size that will be kept in cache\n :param device_path: on-disk device path, used when quarantining an obj\n :param logger: logger caller wants this object to use\n :param quarantine_hook: 1-arg callable called w/reason when quarantined\n :param use_splice: if true, use zero-copy splice() to send data\n :param pipe_size: size of pipe buffer used in zero-copy operations\n :param diskfile: the diskfile creating this DiskFileReader instance\n :param keep_cache: should resulting reads be kept in the buffer cache\n \"\"\"\n def __init__(self, fp, data_file, obj_size, etag,\n disk_chunk_size, keep_cache_size, device_path, logger,\n quarantine_hook, use_splice, pipe_size, diskfile,\n keep_cache=False):\n # Parameter tracking\n self._fp = fp\n self._data_file = data_file\n self._obj_size = obj_size\n self._etag = etag\n self._diskfile = diskfile\n self._disk_chunk_size = disk_chunk_size\n self._device_path = device_path\n self._logger = logger\n self._quarantine_hook = quarantine_hook\n self._use_splice = use_splice\n self._pipe_size = pipe_size\n if keep_cache:\n # Caller suggests we keep this in cache, only do it if the\n # object's size is less than the maximum.\n self._keep_cache = obj_size < keep_cache_size\n else:\n self._keep_cache = False\n\n # Internal Attributes\n self._iter_etag = None\n self._bytes_read = 0\n self._started_at_0 = False\n self._read_to_eof = False\n self._md5_of_sent_bytes = None\n self._suppress_file_closing = False\n self._quarantined_dir = None\n\n @property\n def manager(self):\n return self._diskfile.manager\n\n def _init_checks(self):\n if self._fp.tell() == 0:\n self._started_at_0 = True\n self._iter_etag = hashlib.md5()\n\n def _update_checks(self, chunk):\n if self._iter_etag:\n self._iter_etag.update(chunk)\n\n def __iter__(self):\n \"\"\"Returns an iterator over the data file.\"\"\"\n try:\n dropped_cache = 0\n self._bytes_read = 0\n self._started_at_0 = False\n self._read_to_eof = False\n self._init_checks()\n while True:\n chunk = self._fp.read(self._disk_chunk_size)\n if chunk:\n self._update_checks(chunk)\n self._bytes_read += len(chunk)\n if self._bytes_read - dropped_cache > DROP_CACHE_WINDOW:\n self._drop_cache(self._fp.fileno(), dropped_cache,\n self._bytes_read - dropped_cache)\n dropped_cache = self._bytes_read\n yield chunk\n else:\n self._read_to_eof = True\n self._drop_cache(self._fp.fileno(), dropped_cache,\n self._bytes_read - dropped_cache)\n break\n finally:\n if not self._suppress_file_closing:\n self.close()\n\n def can_zero_copy_send(self):\n return self._use_splice\n\n def zero_copy_send(self, wsockfd):\n \"\"\"\n Does some magic with splice() and tee() to move stuff from disk to\n network without ever touching userspace.\n\n :param wsockfd: file descriptor (integer) of the socket out which to\n send data\n \"\"\"\n # Note: if we ever add support for zero-copy ranged GET responses,\n # we'll have to make this conditional.\n self._started_at_0 = True\n\n rfd = self._fp.fileno()\n client_rpipe, client_wpipe = os.pipe()\n hash_rpipe, hash_wpipe = os.pipe()\n md5_sockfd = get_md5_socket()\n\n # The actual amount allocated to the pipe may be rounded up to the\n # nearest multiple of the page size. If we have the memory allocated,\n # we may as well use it.\n #\n # Note: this will raise IOError on failure, so we don't bother\n # checking the return value.\n pipe_size = fcntl.fcntl(client_rpipe, F_SETPIPE_SZ, self._pipe_size)\n fcntl.fcntl(hash_rpipe, F_SETPIPE_SZ, pipe_size)\n\n dropped_cache = 0\n self._bytes_read = 0\n try:\n while True:\n # Read data from disk to pipe\n (bytes_in_pipe, _1, _2) = splice(\n rfd, None, client_wpipe, None, pipe_size, 0)\n if bytes_in_pipe == 0:\n self._read_to_eof = True\n self._drop_cache(rfd, dropped_cache,\n self._bytes_read - dropped_cache)\n break\n self._bytes_read += bytes_in_pipe\n\n # \"Copy\" data from pipe A to pipe B (really just some pointer\n # manipulation in the kernel, not actual copying).\n bytes_copied = tee(client_rpipe, hash_wpipe, bytes_in_pipe, 0)\n if bytes_copied != bytes_in_pipe:\n # We teed data between two pipes of equal size, and the\n # destination pipe was empty. If, somehow, the destination\n # pipe was full before all the data was teed, we should\n # fail here. If we don't raise an exception, then we will\n # have the incorrect MD5 hash once the object has been\n # sent out, causing a false-positive quarantine.\n raise Exception(\"tee() failed: tried to move %d bytes, \"\n \"but only moved %d\" %\n (bytes_in_pipe, bytes_copied))\n # Take the data and feed it into an in-kernel MD5 socket. The\n # MD5 socket hashes data that is written to it. Reading from\n # it yields the MD5 checksum of the written data.\n #\n # Note that we don't have to worry about splice() returning\n # None here (which happens on EWOULDBLOCK); we're splicing\n # $bytes_in_pipe bytes from a pipe with exactly that many\n # bytes in it, so read won't block, and we're splicing it into\n # an MD5 socket, which synchronously hashes any data sent to\n # it, so writing won't block either.\n (hashed, _1, _2) = splice(hash_rpipe, None, md5_sockfd, None,\n bytes_in_pipe, splice.SPLICE_F_MORE)\n if hashed != bytes_in_pipe:\n raise Exception(\"md5 socket didn't take all the data? \"\n \"(tried to write %d, but wrote %d)\" %\n (bytes_in_pipe, hashed))\n\n while bytes_in_pipe > 0:\n try:\n res = splice(client_rpipe, None, wsockfd, None,\n bytes_in_pipe, 0)\n bytes_in_pipe -= res[0]\n except IOError as exc:\n if exc.errno == errno.EWOULDBLOCK:\n trampoline(wsockfd, write=True)\n else:\n raise\n\n if self._bytes_read - dropped_cache > DROP_CACHE_WINDOW:\n self._drop_cache(rfd, dropped_cache,\n self._bytes_read - dropped_cache)\n dropped_cache = self._bytes_read\n finally:\n # Linux MD5 sockets return '00000000000000000000000000000000' for\n # the checksum if you didn't write any bytes to them, instead of\n # returning the correct value.\n if self._bytes_read > 0:\n bin_checksum = os.read(md5_sockfd, 16)\n hex_checksum = ''.join(\"%02x\" % ord(c) for c in bin_checksum)\n else:\n hex_checksum = MD5_OF_EMPTY_STRING\n self._md5_of_sent_bytes = hex_checksum\n\n os.close(client_rpipe)\n os.close(client_wpipe)\n os.close(hash_rpipe)\n os.close(hash_wpipe)\n os.close(md5_sockfd)\n self.close()\n\n def app_iter_range(self, start, stop):\n \"\"\"\n Returns an iterator over the data file for range (start, stop)\n\n \"\"\"\n if start or start == 0:\n self._fp.seek(start)\n if stop is not None:\n length = stop - start\n else:\n length = None\n try:\n for chunk in self:\n if length is not None:\n length -= len(chunk)\n if length < 0:\n # Chop off the extra:\n yield chunk[:length]\n break\n yield chunk\n finally:\n if not self._suppress_file_closing:\n self.close()\n\n def app_iter_ranges(self, ranges, content_type, boundary, size):\n \"\"\"\n Returns an iterator over the data file for a set of ranges\n\n \"\"\"\n if not ranges:\n yield ''\n else:\n try:\n self._suppress_file_closing = True\n for chunk in multi_range_iterator(\n ranges, content_type, boundary, size,\n self.app_iter_range):\n yield chunk\n finally:\n self._suppress_file_closing = False\n self.close()\n\n def _drop_cache(self, fd, offset, length):\n \"\"\"\n Method for no-oping buffer cache drop method.\n\n :param fd: file descriptor or filename\n \"\"\"\n if not self._keep_cache:\n drop_buffer_cache(fd, offset, length)\n\n def _quarantine(self, msg):\n self._quarantined_dir = self.manager.quarantine_renamer(\n self._device_path, self._data_file)\n self._logger.warning(\"Quarantined object %s: %s\" % (\n self._data_file, msg))\n self._logger.increment('quarantines')\n self._quarantine_hook(msg)\n\n def _handle_close_quarantine(self):\n \"\"\"Check if file needs to be quarantined\"\"\"\n if self._iter_etag and not self._md5_of_sent_bytes:\n self._md5_of_sent_bytes = self._iter_etag.hexdigest()\n\n if self._bytes_read != self._obj_size:\n self._quarantine(\n \"Bytes read: %s, does not match metadata: %s\" % (\n self._bytes_read, self._obj_size))\n elif self._md5_of_sent_bytes and \\\n self._etag != self._md5_of_sent_bytes:\n self._quarantine(\n \"ETag %s and file's md5 %s do not match\" % (\n self._etag, self._md5_of_sent_bytes))\n\n def close(self):\n \"\"\"\n Close the open file handle if present.\n\n For this specific implementation, this method will handle quarantining\n the file if necessary.\n \"\"\"\n if self._fp:\n try:\n if self._started_at_0 and self._read_to_eof:\n self._handle_close_quarantine()\n except DiskFileQuarantined:\n raise\n except (Exception, Timeout) as e:\n self._logger.error(_(\n 'ERROR DiskFile %(data_file)s'\n ' close failure: %(exc)s : %(stack)s'),\n {'exc': e, 'stack': ''.join(traceback.format_stack()),\n 'data_file': self._data_file})\n finally:\n fp, self._fp = self._fp, None\n fp.close()\n\n\nclass BaseDiskFile(object):\n \"\"\"\n Manage object files.\n\n This specific implementation manages object files on a disk formatted with\n a POSIX-compliant file system that supports extended attributes as\n metadata on a file or directory.\n\n .. note::\n\n The arguments to the constructor are considered implementation\n specific. The API does not define the constructor arguments.\n\n The following path format is used for data file locations:\n <devices_path/<device_dir>/<datadir>/<partdir>/<suffixdir>/<hashdir>/\n <datafile>.<ext>\n\n :param mgr: associated DiskFileManager instance\n :param device_path: path to the target device or drive\n :param partition: partition on the device in which the object lives\n :param account: account name for the object\n :param container: container name for the object\n :param obj: object name for the object\n :param _datadir: override the full datadir otherwise constructed here\n :param policy: the StoragePolicy instance\n :param use_splice: if true, use zero-copy splice() to send data\n :param pipe_size: size of pipe buffer used in zero-copy operations\n :param use_linkat: if True, use open() with linkat() to create obj file\n :param open_expired: if True, open() will not raise a DiskFileExpired if\n object is expired\n \"\"\"\n reader_cls = None # must be set by subclasses\n writer_cls = None # must be set by subclasses\n\n def __init__(self, mgr, device_path, partition,\n account=None, container=None, obj=None, _datadir=None,\n policy=None, use_splice=False, pipe_size=None,\n use_linkat=False, open_expired=False, **kwargs):\n self._manager = mgr\n self._device_path = device_path\n self._logger = mgr.logger\n self._disk_chunk_size = mgr.disk_chunk_size\n self._bytes_per_sync = mgr.bytes_per_sync\n self._use_splice = use_splice\n self._pipe_size = pipe_size\n self._use_linkat = use_linkat\n self._open_expired = open_expired\n # This might look a lttle hacky i.e tracking number of newly created\n # dirs to fsync only those many later. If there is a better way,\n # please suggest.\n # Or one could consider getting rid of doing fsyncs on dirs altogether\n # and mounting XFS with the 'dirsync' mount option which should result\n # in all entry fops being carried out synchronously.\n self._dirs_created = 0\n self.policy = policy\n if account and container and obj:\n self._name = '/' + '/'.join((account, container, obj))\n self._account = account\n self._container = container\n self._obj = obj\n else:\n # gets populated when we read the metadata\n self._name = None\n self._account = None\n self._container = None\n self._obj = None\n self._tmpdir = join(device_path, get_tmp_dir(policy))\n self._ondisk_info = None\n self._metadata = None\n self._datafile_metadata = None\n self._metafile_metadata = None\n self._data_file = None\n self._fp = None\n self._quarantined_dir = None\n self._content_length = None\n if _datadir:\n self._datadir = _datadir\n else:\n name_hash = hash_path(account, container, obj)\n self._datadir = join(\n device_path, storage_directory(get_data_dir(policy),\n partition, name_hash))\n\n @property\n def manager(self):\n return self._manager\n\n @property\n def account(self):\n return self._account\n\n @property\n def container(self):\n return self._container\n\n @property\n def obj(self):\n return self._obj\n\n @property\n def content_length(self):\n if self._metadata is None:\n raise DiskFileNotOpen()\n return self._content_length\n\n @property\n def timestamp(self):\n if self._metadata is None:\n raise DiskFileNotOpen()\n return Timestamp(self._metadata.get('X-Timestamp'))\n\n @property\n def data_timestamp(self):\n if self._datafile_metadata is None:\n raise DiskFileNotOpen()\n return Timestamp(self._datafile_metadata.get('X-Timestamp'))\n\n @property\n def durable_timestamp(self):\n \"\"\"\n Provides the timestamp of the newest data file found in the object\n directory.\n\n :return: A Timestamp instance, or None if no data file was found.\n :raises DiskFileNotOpen: if the open() method has not been previously\n called on this instance.\n \"\"\"\n if self._ondisk_info is None:\n raise DiskFileNotOpen()\n if self._datafile_metadata:\n return Timestamp(self._datafile_metadata.get('X-Timestamp'))\n return None\n\n @property\n def fragments(self):\n return None\n\n @property\n def content_type(self):\n if self._metadata is None:\n raise DiskFileNotOpen()\n return self._metadata.get('Content-Type')\n\n @property\n def content_type_timestamp(self):\n if self._metadata is None:\n raise DiskFileNotOpen()\n t = self._metadata.get('Content-Type-Timestamp',\n self._datafile_metadata.get('X-Timestamp'))\n return Timestamp(t)\n\n @classmethod\n def from_hash_dir(cls, mgr, hash_dir_path, device_path, partition, policy):\n return cls(mgr, device_path, None, partition, _datadir=hash_dir_path,\n policy=policy)\n\n def open(self):\n \"\"\"\n Open the object.\n\n This implementation opens the data file representing the object, reads\n the associated metadata in the extended attributes, additionally\n combining metadata from fast-POST `.meta` files.\n\n .. note::\n\n An implementation is allowed to raise any of the following\n exceptions, but is only required to raise `DiskFileNotExist` when\n the object representation does not exist.\n\n :raises DiskFileCollision: on name mis-match with metadata\n :raises DiskFileNotExist: if the object does not exist\n :raises DiskFileDeleted: if the object was previously deleted\n :raises DiskFileQuarantined: if while reading metadata of the file\n some data did pass cross checks\n :returns: itself for use as a context manager\n \"\"\"\n # First figure out if the data directory exists\n try:\n files = os.listdir(self._datadir)\n except OSError as err:\n if err.errno == errno.ENOTDIR:\n # If there's a file here instead of a directory, quarantine\n # it; something's gone wrong somewhere.\n raise self._quarantine(\n # hack: quarantine_renamer actually renames the directory\n # enclosing the filename you give it, but here we just\n # want this one file and not its parent.\n os.path.join(self._datadir, \"made-up-filename\"),\n \"Expected directory, found file at %s\" % self._datadir)\n elif err.errno != errno.ENOENT:\n raise DiskFileError(\n \"Error listing directory %s: %s\" % (self._datadir, err))\n # The data directory does not exist, so the object cannot exist.\n files = []\n\n # gather info about the valid files to use to open the DiskFile\n file_info = self._get_ondisk_files(files)\n\n self._data_file = file_info.get('data_file')\n if not self._data_file:\n raise self._construct_exception_from_ts_file(**file_info)\n self._fp = self._construct_from_data_file(**file_info)\n # This method must populate the internal _metadata attribute.\n self._metadata = self._metadata or {}\n return self\n\n def __enter__(self):\n \"\"\"\n Context enter.\n\n .. note::\n\n An implementation shall raise `DiskFileNotOpen` when has not\n previously invoked the :func:`swift.obj.diskfile.DiskFile.open`\n method.\n \"\"\"\n if self._metadata is None:\n raise DiskFileNotOpen()\n return self\n\n def __exit__(self, t, v, tb):\n \"\"\"\n Context exit.\n\n .. note::\n\n This method will be invoked by the object server while servicing\n the REST API *before* the object has actually been read. It is the\n responsibility of the implementation to properly handle that.\n \"\"\"\n if self._fp is not None:\n fp, self._fp = self._fp, None\n fp.close()\n\n def _quarantine(self, data_file, msg):\n \"\"\"\n Quarantine a file; responsible for incrementing the associated logger's\n count of quarantines.\n\n :param data_file: full path of data file to quarantine\n :param msg: reason for quarantining to be included in the exception\n :returns: DiskFileQuarantined exception object\n \"\"\"\n self._quarantined_dir = self.manager.quarantine_renamer(\n self._device_path, data_file)\n self._logger.warning(\"Quarantined object %s: %s\" % (\n data_file, msg))\n self._logger.increment('quarantines')\n return DiskFileQuarantined(msg)\n\n def _get_ondisk_files(self, files):\n \"\"\"\n Determine the on-disk files to use.\n\n :param files: a list of files in the object's dir\n :returns: dict of files to use having keys 'data_file', 'ts_file',\n 'meta_file'\n \"\"\"\n raise NotImplementedError\n\n def _construct_exception_from_ts_file(self, ts_file, **kwargs):\n \"\"\"\n If a tombstone is present it means the object is considered\n deleted. We just need to pull the metadata from the tombstone file\n which has the timestamp to construct the deleted exception. If there\n was no tombstone, just report it does not exist.\n\n :param ts_file: the tombstone file name found on disk\n :returns: DiskFileDeleted if the ts_file was provided, else\n DiskFileNotExist\n \"\"\"\n if not ts_file:\n exc = DiskFileNotExist()\n else:\n try:\n metadata = self._failsafe_read_metadata(ts_file, ts_file)\n except DiskFileQuarantined:\n # If the tombstone's corrupted, quarantine it and pretend it\n # wasn't there\n exc = DiskFileNotExist()\n else:\n # All well and good that we have found a tombstone file, but\n # we don't have a data file so we are just going to raise an\n # exception that we could not find the object, providing the\n # tombstone's timestamp.\n exc = DiskFileDeleted(metadata=metadata)\n return exc\n\n def _verify_name_matches_hash(self, data_file):\n \"\"\"\n\n :param data_file: data file name, used when quarantines occur\n \"\"\"\n hash_from_fs = os.path.basename(self._datadir)\n hash_from_name = hash_path(self._name.lstrip('/'))\n if hash_from_fs != hash_from_name:\n raise self._quarantine(\n data_file,\n \"Hash of name in metadata does not match directory name\")\n\n def _verify_data_file(self, data_file, fp):\n \"\"\"\n Verify the metadata's name value matches what we think the object is\n named.\n\n :param data_file: data file name being consider, used when quarantines\n occur\n :param fp: open file pointer so that we can `fstat()` the file to\n verify the on-disk size with Content-Length metadata value\n :raises DiskFileCollision: if the metadata stored name does not match\n the referenced name of the file\n :raises DiskFileExpired: if the object has expired\n :raises DiskFileQuarantined: if data inconsistencies were detected\n between the metadata and the file-system\n metadata\n \"\"\"\n try:\n mname = self._metadata['name']\n except KeyError:\n raise self._quarantine(data_file, \"missing name metadata\")\n else:\n if mname != self._name:\n self._logger.error(\n _('Client path %(client)s does not match '\n 'path stored in object metadata %(meta)s'),\n {'client': self._name, 'meta': mname})\n raise DiskFileCollision('Client path does not match path '\n 'stored in object metadata')\n try:\n x_delete_at = int(self._metadata['X-Delete-At'])\n except KeyError:\n pass\n except ValueError:\n # Quarantine, the x-delete-at key is present but not an\n # integer.\n raise self._quarantine(\n data_file, \"bad metadata x-delete-at value %s\" % (\n self._metadata['X-Delete-At']))\n else:\n if x_delete_at <= time.time() and not self._open_expired:\n raise DiskFileExpired(metadata=self._metadata)\n try:\n metadata_size = int(self._metadata['Content-Length'])\n except KeyError:\n raise self._quarantine(\n data_file, \"missing content-length in metadata\")\n except ValueError:\n # Quarantine, the content-length key is present but not an\n # integer.\n raise self._quarantine(\n data_file, \"bad metadata content-length value %s\" % (\n self._metadata['Content-Length']))\n fd = fp.fileno()\n try:\n statbuf = os.fstat(fd)\n except OSError as err:\n # Quarantine, we can't successfully stat the file.\n raise self._quarantine(data_file, \"not stat-able: %s\" % err)\n else:\n obj_size = statbuf.st_size\n if obj_size != metadata_size:\n raise self._quarantine(\n data_file, \"metadata content-length %s does\"\n \" not match actual object size %s\" % (\n metadata_size, statbuf.st_size))\n self._content_length = obj_size\n return obj_size\n\n def _failsafe_read_metadata(self, source, quarantine_filename=None):\n \"\"\"\n Read metadata from source object file. In case of failure, quarantine\n the file.\n\n Takes source and filename separately so we can read from an open\n file if we have one.\n\n :param source: file descriptor or filename to load the metadata from\n :param quarantine_filename: full path of file to load the metadata from\n \"\"\"\n try:\n return read_metadata(source)\n except (DiskFileXattrNotSupported, DiskFileNotExist):\n raise\n except Exception as err:\n raise self._quarantine(\n quarantine_filename,\n \"Exception reading metadata: %s\" % err)\n\n def _merge_content_type_metadata(self, ctype_file):\n \"\"\"\n When a second .meta file is providing the most recent Content-Type\n metadata then merge it into the metafile_metadata.\n\n :param ctype_file: An on-disk .meta file\n \"\"\"\n ctypefile_metadata = self._failsafe_read_metadata(\n ctype_file, ctype_file)\n if ('Content-Type' in ctypefile_metadata\n and (ctypefile_metadata.get('Content-Type-Timestamp') >\n self._metafile_metadata.get('Content-Type-Timestamp'))\n and (ctypefile_metadata.get('Content-Type-Timestamp') >\n self.data_timestamp)):\n self._metafile_metadata['Content-Type'] = \\\n ctypefile_metadata['Content-Type']\n self._metafile_metadata['Content-Type-Timestamp'] = \\\n ctypefile_metadata.get('Content-Type-Timestamp')\n\n def _construct_from_data_file(self, data_file, meta_file, ctype_file,\n **kwargs):\n \"\"\"\n Open the `.data` file to fetch its metadata, and fetch the metadata\n from fast-POST `.meta` files as well if any exist, merging them\n properly.\n\n :param data_file: on-disk `.data` file being considered\n :param meta_file: on-disk fast-POST `.meta` file being considered\n :param ctype_file: on-disk fast-POST `.meta` file being considered that\n contains content-type and content-type timestamp\n :returns: an opened data file pointer\n :raises DiskFileError: various exceptions from\n :func:`swift.obj.diskfile.DiskFile._verify_data_file`\n \"\"\"\n fp = open(data_file, 'rb')\n self._datafile_metadata = self._failsafe_read_metadata(fp, data_file)\n self._metadata = {}\n if meta_file:\n self._metafile_metadata = self._failsafe_read_metadata(\n meta_file, meta_file)\n if ctype_file and ctype_file != meta_file:\n self._merge_content_type_metadata(ctype_file)\n sys_metadata = dict(\n [(key, val) for key, val in self._datafile_metadata.items()\n if key.lower() in DATAFILE_SYSTEM_META\n or is_sys_meta('object', key)])\n self._metadata.update(self._metafile_metadata)\n self._metadata.update(sys_metadata)\n # diskfile writer added 'name' to metafile, so remove it here\n self._metafile_metadata.pop('name', None)\n # TODO: the check for Content-Type is only here for tests that\n # create .data files without Content-Type\n if ('Content-Type' in self._datafile_metadata and\n (self.data_timestamp >\n self._metafile_metadata.get('Content-Type-Timestamp'))):\n self._metadata['Content-Type'] = \\\n self._datafile_metadata['Content-Type']\n self._metadata.pop('Content-Type-Timestamp', None)\n else:\n self._metadata.update(self._datafile_metadata)\n if self._name is None:\n # If we don't know our name, we were just given a hash dir at\n # instantiation, so we'd better validate that the name hashes back\n # to us\n self._name = self._metadata['name']\n self._verify_name_matches_hash(data_file)\n self._verify_data_file(data_file, fp)\n return fp\n\n def get_metafile_metadata(self):\n \"\"\"\n Provide the metafile metadata for a previously opened object as a\n dictionary. This is metadata that was written by a POST and does not\n include any persistent metadata that was set by the original PUT.\n\n :returns: object's .meta file metadata dictionary, or None if there is\n no .meta file\n :raises DiskFileNotOpen: if the\n :func:`swift.obj.diskfile.DiskFile.open` method was not previously\n invoked\n \"\"\"\n if self._metadata is None:\n raise DiskFileNotOpen()\n return self._metafile_metadata\n\n def get_datafile_metadata(self):\n \"\"\"\n Provide the datafile metadata for a previously opened object as a\n dictionary. This is metadata that was included when the object was\n first PUT, and does not include metadata set by any subsequent POST.\n\n :returns: object's datafile metadata dictionary\n :raises DiskFileNotOpen: if the\n :func:`swift.obj.diskfile.DiskFile.open` method was not previously\n invoked\n \"\"\"\n if self._datafile_metadata is None:\n raise DiskFileNotOpen()\n return self._datafile_metadata\n\n def get_metadata(self):\n \"\"\"\n Provide the metadata for a previously opened object as a dictionary.\n\n :returns: object's metadata dictionary\n :raises DiskFileNotOpen: if the\n :func:`swift.obj.diskfile.DiskFile.open` method was not previously\n invoked\n \"\"\"\n if self._metadata is None:\n raise DiskFileNotOpen()\n return self._metadata\n\n def read_metadata(self):\n \"\"\"\n Return the metadata for an object without requiring the caller to open\n the object first.\n\n :returns: metadata dictionary for an object\n :raises DiskFileError: this implementation will raise the same\n errors as the `open()` method.\n \"\"\"\n with self.open():\n return self.get_metadata()\n\n def reader(self, keep_cache=False,\n _quarantine_hook=lambda m: None):\n \"\"\"\n Return a :class:`swift.common.swob.Response` class compatible\n \"`app_iter`\" object as defined by\n :class:`swift.obj.diskfile.DiskFileReader`.\n\n For this implementation, the responsibility of closing the open file\n is passed to the :class:`swift.obj.diskfile.DiskFileReader` object.\n\n :param keep_cache: caller's preference for keeping data read in the\n OS buffer cache\n :param _quarantine_hook: 1-arg callable called when obj quarantined;\n the arg is the reason for quarantine.\n Default is to ignore it.\n Not needed by the REST layer.\n :returns: a :class:`swift.obj.diskfile.DiskFileReader` object\n \"\"\"\n dr = self.reader_cls(\n self._fp, self._data_file, int(self._metadata['Content-Length']),\n self._metadata['ETag'], self._disk_chunk_size,\n self._manager.keep_cache_size, self._device_path, self._logger,\n use_splice=self._use_splice, quarantine_hook=_quarantine_hook,\n pipe_size=self._pipe_size, diskfile=self, keep_cache=keep_cache)\n # At this point the reader object is now responsible for closing\n # the file pointer.\n self._fp = None\n return dr\n\n def _get_tempfile(self):\n fallback_to_mkstemp = False\n tmppath = None\n if self._use_linkat:\n self._dirs_created = makedirs_count(self._datadir)\n try:\n fd = os.open(self._datadir, O_TMPFILE | os.O_WRONLY)\n except OSError as err:\n if err.errno in (errno.EOPNOTSUPP, errno.EISDIR, errno.EINVAL):\n msg = 'open(%s, O_TMPFILE | O_WRONLY) failed: %s \\\n Falling back to using mkstemp()' \\\n % (self._datadir, os.strerror(err.errno))\n self._logger.warning(msg)\n fallback_to_mkstemp = True\n else:\n raise\n if not self._use_linkat or fallback_to_mkstemp:\n if not exists(self._tmpdir):\n mkdirs(self._tmpdir)\n fd, tmppath = mkstemp(dir=self._tmpdir)\n return fd, tmppath\n\n @contextmanager\n def create(self, size=None):\n \"\"\"\n Context manager to create a file. We create a temporary file first, and\n then return a DiskFileWriter object to encapsulate the state.\n\n .. note::\n\n An implementation is not required to perform on-disk\n preallocations even if the parameter is specified. But if it does\n and it fails, it must raise a `DiskFileNoSpace` exception.\n\n :param size: optional initial size of file to explicitly allocate on\n disk\n :raises DiskFileNoSpace: if a size is specified and allocation fails\n \"\"\"\n try:\n fd, tmppath = self._get_tempfile()\n except OSError as err:\n if err.errno in (errno.ENOSPC, errno.EDQUOT):\n # No more inodes in filesystem\n raise DiskFileNoSpace()\n raise\n dfw = None\n try:\n if size is not None and size > 0:\n try:\n fallocate(fd, size)\n except OSError as err:\n if err.errno in (errno.ENOSPC, errno.EDQUOT):\n raise DiskFileNoSpace()\n raise\n dfw = self.writer_cls(self._name, self._datadir, fd, tmppath,\n bytes_per_sync=self._bytes_per_sync,\n diskfile=self)\n yield dfw\n finally:\n try:\n os.close(fd)\n except OSError:\n pass\n if (dfw is None) or (not dfw.put_succeeded):\n # Try removing the temp file only if put did NOT succeed.\n #\n # dfw.put_succeeded is set to True after renamer() succeeds in\n # DiskFileWriter._finalize_put()\n try:\n if tmppath:\n # when mkstemp() was used\n os.unlink(tmppath)\n except OSError:\n self._logger.exception('Error removing tempfile: %s' %\n tmppath)\n\n def write_metadata(self, metadata):\n \"\"\"\n Write a block of metadata to an object without requiring the caller to\n create the object first. Supports fast-POST behavior semantics.\n\n :param metadata: dictionary of metadata to be associated with the\n object\n :raises DiskFileError: this implementation will raise the same\n errors as the `create()` method.\n \"\"\"\n with self.create() as writer:\n writer._extension = '.meta'\n writer.put(metadata)\n\n def delete(self, timestamp):\n \"\"\"\n Delete the object.\n\n This implementation creates a tombstone file using the given\n timestamp, and removes any older versions of the object file. Any\n file that has an older timestamp than timestamp will be deleted.\n\n .. note::\n\n An implementation is free to use or ignore the timestamp\n parameter.\n\n :param timestamp: timestamp to compare with each file\n :raises DiskFileError: this implementation will raise the same\n errors as the `create()` method.\n \"\"\"\n # this is dumb, only tests send in strings\n timestamp = Timestamp(timestamp)\n with self.create() as deleter:\n deleter._extension = '.ts'\n deleter.put({'X-Timestamp': timestamp.internal})\n\n\nclass DiskFileReader(BaseDiskFileReader):\n pass\n\n\nclass DiskFileWriter(BaseDiskFileWriter):\n def put(self, metadata):\n \"\"\"\n Finalize writing the file on disk.\n\n :param metadata: dictionary of metadata to be associated with the\n object\n \"\"\"\n super(DiskFileWriter, self)._put(metadata, True)\n\n\nclass DiskFile(BaseDiskFile):\n reader_cls = DiskFileReader\n writer_cls = DiskFileWriter\n\n def _get_ondisk_files(self, files):\n self._ondisk_info = self.manager.get_ondisk_files(files, self._datadir)\n return self._ondisk_info\n\n\n@DiskFileRouter.register(REPL_POLICY)\nclass DiskFileManager(BaseDiskFileManager):\n diskfile_cls = DiskFile\n\n def _process_ondisk_files(self, exts, results, **kwargs):\n \"\"\"\n Implement replication policy specific handling of .data files.\n\n :param exts: dict of lists of file info, keyed by extension\n :param results: a dict that may be updated with results\n \"\"\"\n if exts.get('.data'):\n for ext in exts.keys():\n if ext == '.data':\n # older .data's are obsolete\n exts[ext], obsolete = self._split_gte_timestamp(\n exts[ext], exts['.data'][0]['timestamp'])\n else:\n # other files at same or older timestamp as most recent\n # data are obsolete\n exts[ext], obsolete = self._split_gt_timestamp(\n exts[ext], exts['.data'][0]['timestamp'])\n results.setdefault('obsolete', []).extend(obsolete)\n\n # set results\n results['data_info'] = exts['.data'][0]\n\n # .meta files *may* be ready for reclaim if there is no data\n if exts.get('.meta') and not exts.get('.data'):\n results.setdefault('possible_reclaim', []).extend(\n exts.get('.meta'))\n\n def _update_suffix_hashes(self, hashes, ondisk_info):\n \"\"\"\n Applies policy specific updates to the given dict of md5 hashes for\n the given ondisk_info.\n\n :param hashes: a dict of md5 hashes to be updated\n :param ondisk_info: a dict describing the state of ondisk files, as\n returned by get_ondisk_files\n \"\"\"\n if 'data_info' in ondisk_info:\n file_info = ondisk_info['data_info']\n hashes[None].update(\n file_info['timestamp'].internal + file_info['ext'])\n\n def _hash_suffix(self, path):\n \"\"\"\n Performs reclamation and returns an md5 of all (remaining) files.\n\n :param path: full path to directory\n :raises PathNotDir: if given path is not a valid directory\n :raises OSError: for non-ENOTDIR errors\n :returns: md5 of files in suffix\n \"\"\"\n hashes = self._hash_suffix_dir(path)\n return hashes[None].hexdigest()\n\n\nclass ECDiskFileReader(BaseDiskFileReader):\n def __init__(self, fp, data_file, obj_size, etag,\n disk_chunk_size, keep_cache_size, device_path, logger,\n quarantine_hook, use_splice, pipe_size, diskfile,\n keep_cache=False):\n super(ECDiskFileReader, self).__init__(\n fp, data_file, obj_size, etag,\n disk_chunk_size, keep_cache_size, device_path, logger,\n quarantine_hook, use_splice, pipe_size, diskfile, keep_cache)\n self.frag_buf = None\n self.frag_offset = 0\n self.frag_size = self._diskfile.policy.fragment_size\n\n def _init_checks(self):\n super(ECDiskFileReader, self)._init_checks()\n # for a multi-range GET this will be called at the start of each range;\n # only initialise the frag_buf for reads starting at 0.\n # TODO: reset frag buf to '' if tell() shows that start is on a frag\n # boundary so that we check frags selected by a range not starting at 0\n if self._started_at_0:\n self.frag_buf = ''\n else:\n self.frag_buf = None\n\n def _check_frag(self, frag):\n if not frag:\n return\n if not isinstance(frag, six.binary_type):\n # ECInvalidParameter can be returned if the frag violates the input\n # format so for safety, check the input chunk if it's binary to\n # avoid quarantining a valid fragment archive.\n self._diskfile._logger.warn(\n _('Unexpected fragment data type (not quarantined)'\n '%(datadir)s: %(type)s at offset 0x%(offset)x'),\n {'datadir': self._diskfile._datadir,\n 'type': type(frag),\n 'offset': self.frag_offset})\n return\n\n try:\n self._diskfile.policy.pyeclib_driver.get_metadata(frag)\n except (ECInvalidFragmentMetadata, ECBadFragmentChecksum,\n ECInvalidParameter):\n # Any of these exceptions may be returned from ECDriver with a\n # corrupted fragment.\n msg = 'Invalid EC metadata at offset 0x%x' % self.frag_offset\n self._quarantine(msg)\n # We have to terminate the response iter with an exception but it\n # can't be StopIteration, this will produce a STDERR traceback in\n # eventlet.wsgi if you have eventlet_debug turned on; but any\n # attempt to finish the iterator cleanly won't trigger the needful\n # error handling cleanup - failing to do so, and yet still failing\n # to deliver all promised bytes will hang the HTTP connection\n raise DiskFileQuarantined(msg)\n except ECDriverError as err:\n self._diskfile._logger.warn(\n _('Problem checking EC fragment %(datadir)s: %(err)s'),\n {'datadir': self._diskfile._datadir, 'err': err})\n\n def _update_checks(self, chunk):\n super(ECDiskFileReader, self)._update_checks(chunk)\n if self.frag_buf is not None:\n self.frag_buf += chunk\n cursor = 0\n while len(self.frag_buf) >= cursor + self.frag_size:\n self._check_frag(self.frag_buf[cursor:cursor + self.frag_size])\n cursor += self.frag_size\n self.frag_offset += self.frag_size\n if cursor:\n self.frag_buf = self.frag_buf[cursor:]\n\n def _handle_close_quarantine(self):\n super(ECDiskFileReader, self)._handle_close_quarantine()\n self._check_frag(self.frag_buf)\n\n\nclass ECDiskFileWriter(BaseDiskFileWriter):\n\n def _finalize_durable(self, data_file_path, durable_data_file_path):\n exc = None\n try:\n try:\n os.rename(data_file_path, durable_data_file_path)\n fsync_dir(self._datadir)\n except (OSError, IOError) as err:\n if err.errno not in (errno.ENOSPC, errno.EDQUOT):\n # re-raise to catch all handler\n raise\n params = {'file': durable_data_file_path, 'err': err}\n self.manager.logger.exception(\n _('No space left on device for %(file)s (%(err)s)'),\n params)\n exc = DiskFileNoSpace(\n 'No space left on device for %(file)s (%(err)s)' % params)\n else:\n try:\n self.manager.cleanup_ondisk_files(self._datadir)\n except OSError as os_err:\n self.manager.logger.exception(\n _('Problem cleaning up %(datadir)s (%(err)s)'),\n {'datadir': self._datadir, 'err': os_err})\n except Exception as err:\n params = {'file': durable_data_file_path, 'err': err}\n self.manager.logger.exception(\n _('Problem making data file durable %(file)s (%(err)s)'),\n params)\n exc = DiskFileError(\n 'Problem making data file durable %(file)s (%(err)s)' % params)\n if exc:\n raise exc\n\n def commit(self, timestamp):\n \"\"\"\n Finalize put by renaming the object data file to include a durable\n marker. We do this for EC policy because it requires a 2-phase put\n commit confirmation.\n\n :param timestamp: object put timestamp, an instance of\n :class:`~swift.common.utils.Timestamp`\n :raises DiskFileError: if the diskfile frag_index has not been set\n (either during initialisation or a call to put())\n \"\"\"\n data_file_path = join(\n self._datadir, self.manager.make_on_disk_filename(\n timestamp, '.data', self._diskfile._frag_index))\n durable_data_file_path = os.path.join(\n self._datadir, self.manager.make_on_disk_filename(\n timestamp, '.data', self._diskfile._frag_index, durable=True))\n tpool_reraise(\n self._finalize_durable, data_file_path, durable_data_file_path)\n\n def put(self, metadata):\n \"\"\"\n The only difference between this method and the replication policy\n DiskFileWriter method is adding the frag index to the metadata.\n\n :param metadata: dictionary of metadata to be associated with object\n \"\"\"\n fi = None\n cleanup = True\n if self._extension == '.data':\n # generally we treat the fragment index provided in metadata as\n # canon, but if it's unavailable (e.g. tests) it's reasonable to\n # use the frag_index provided at instantiation. Either way make\n # sure that the fragment index is included in object sysmeta.\n fi = metadata.setdefault('X-Object-Sysmeta-Ec-Frag-Index',\n self._diskfile._frag_index)\n fi = self.manager.validate_fragment_index(fi)\n self._diskfile._frag_index = fi\n # defer cleanup until commit() writes makes diskfile durable\n cleanup = False\n super(ECDiskFileWriter, self)._put(metadata, cleanup, frag_index=fi)\n\n\nclass ECDiskFile(BaseDiskFile):\n\n reader_cls = ECDiskFileReader\n writer_cls = ECDiskFileWriter\n\n def __init__(self, *args, **kwargs):\n super(ECDiskFile, self).__init__(*args, **kwargs)\n frag_index = kwargs.get('frag_index')\n self._frag_index = None\n if frag_index is not None:\n self._frag_index = self.manager.validate_fragment_index(frag_index)\n self._frag_prefs = self._validate_frag_prefs(kwargs.get('frag_prefs'))\n self._durable_frag_set = None\n\n def _validate_frag_prefs(self, frag_prefs):\n \"\"\"\n Validate that frag_prefs is a list of dicts containing expected keys\n 'timestamp' and 'exclude'. Convert timestamp values to Timestamp\n instances and validate that exclude values are valid fragment indexes.\n\n :param frag_prefs: data to validate, should be a list of dicts.\n :raise DiskFileError: if the frag_prefs data is invalid.\n :return: a list of dicts with converted and validated values.\n \"\"\"\n # We *do* want to preserve an empty frag_prefs list because it\n # indicates that a durable file is not required.\n if frag_prefs is None:\n return None\n\n try:\n return [\n {'timestamp': Timestamp(pref['timestamp']),\n 'exclude': [self.manager.validate_fragment_index(fi)\n for fi in pref['exclude']]}\n for pref in frag_prefs]\n except ValueError as e:\n raise DiskFileError(\n 'Bad timestamp in frag_prefs: %r: %s'\n % (frag_prefs, e))\n except DiskFileError as e:\n raise DiskFileError(\n 'Bad fragment index in frag_prefs: %r: %s'\n % (frag_prefs, e))\n except (KeyError, TypeError) as e:\n raise DiskFileError(\n 'Bad frag_prefs: %r: %s' % (frag_prefs, e))\n\n @property\n def durable_timestamp(self):\n \"\"\"\n Provides the timestamp of the newest durable file found in the object\n directory.\n\n :return: A Timestamp instance, or None if no durable file was found.\n :raises DiskFileNotOpen: if the open() method has not been previously\n called on this instance.\n \"\"\"\n if self._ondisk_info is None:\n raise DiskFileNotOpen()\n if self._ondisk_info.get('durable_frag_set'):\n return self._ondisk_info['durable_frag_set'][0]['timestamp']\n return None\n\n @property\n def fragments(self):\n \"\"\"\n Provides information about all fragments that were found in the object\n directory, including fragments without a matching durable file, and\n including any fragment chosen to construct the opened diskfile.\n\n :return: A dict mapping <Timestamp instance> -> <list of frag indexes>,\n or None if the diskfile has not been opened or no fragments\n were found.\n \"\"\"\n if self._ondisk_info:\n frag_sets = self._ondisk_info['frag_sets']\n return dict([(ts, [info['frag_index'] for info in frag_set])\n for ts, frag_set in frag_sets.items()])\n\n def _get_ondisk_files(self, files):\n \"\"\"\n The only difference between this method and the replication policy\n DiskFile method is passing in the frag_index and frag_prefs kwargs to\n our manager's get_ondisk_files method.\n\n :param files: list of file names\n \"\"\"\n self._ondisk_info = self.manager.get_ondisk_files(\n files, self._datadir, frag_index=self._frag_index,\n frag_prefs=self._frag_prefs)\n return self._ondisk_info\n\n def purge(self, timestamp, frag_index):\n \"\"\"\n Remove a tombstone file matching the specified timestamp or\n datafile matching the specified timestamp and fragment index\n from the object directory.\n\n This provides the EC reconstructor/ssync process with a way to\n remove a tombstone or fragment from a handoff node after\n reverting it to its primary node.\n\n The hash will be invalidated, and if empty or invalid the\n hsh_path will be removed on next cleanup_ondisk_files.\n\n :param timestamp: the object timestamp, an instance of\n :class:`~swift.common.utils.Timestamp`\n :param frag_index: fragment archive index, must be\n a whole number or None.\n \"\"\"\n purge_file = self.manager.make_on_disk_filename(\n timestamp, ext='.ts')\n remove_file(os.path.join(self._datadir, purge_file))\n if frag_index is not None:\n # data file may or may not be durable so try removing both filename\n # possibilities\n purge_file = self.manager.make_on_disk_filename(\n timestamp, ext='.data', frag_index=frag_index)\n remove_file(os.path.join(self._datadir, purge_file))\n purge_file = self.manager.make_on_disk_filename(\n timestamp, ext='.data', frag_index=frag_index, durable=True)\n remove_file(os.path.join(self._datadir, purge_file))\n self.manager.invalidate_hash(dirname(self._datadir))\n\n\n@DiskFileRouter.register(EC_POLICY)\nclass ECDiskFileManager(BaseDiskFileManager):\n diskfile_cls = ECDiskFile\n\n def validate_fragment_index(self, frag_index):\n \"\"\"\n Return int representation of frag_index, or raise a DiskFileError if\n frag_index is not a whole number.\n\n :param frag_index: a fragment archive index\n \"\"\"\n try:\n frag_index = int(str(frag_index))\n except (ValueError, TypeError) as e:\n raise DiskFileError(\n 'Bad fragment index: %s: %s' % (frag_index, e))\n if frag_index < 0:\n raise DiskFileError(\n 'Fragment index must not be negative: %s' % frag_index)\n return frag_index\n\n def make_on_disk_filename(self, timestamp, ext=None, frag_index=None,\n ctype_timestamp=None, durable=False, *a, **kw):\n \"\"\"\n Returns the EC specific filename for given timestamp.\n\n :param timestamp: the object timestamp, an instance of\n :class:`~swift.common.utils.Timestamp`\n :param ext: an optional string representing a file extension to be\n appended to the returned file name\n :param frag_index: a fragment archive index, used with .data extension\n only, must be a whole number.\n :param ctype_timestamp: an optional content-type timestamp, an instance\n of :class:`~swift.common.utils.Timestamp`\n :param durable: if True then include a durable marker in data filename.\n :returns: a file name\n :raises DiskFileError: if ext=='.data' and the kwarg frag_index is not\n a whole number\n \"\"\"\n if ext == '.data':\n # for datafiles only we encode the fragment index in the filename\n # to allow archives of different indexes to temporarily be stored\n # on the same node in certain situations\n frag_index = self.validate_fragment_index(frag_index)\n rv = timestamp.internal + '#' + str(frag_index)\n if durable:\n rv += '#d'\n return '%s%s' % (rv, ext)\n return super(ECDiskFileManager, self).make_on_disk_filename(\n timestamp, ext, ctype_timestamp, *a, **kw)\n\n def parse_on_disk_filename(self, filename):\n \"\"\"\n Returns timestamp(s) and other info extracted from a policy specific\n file name. For EC policy the data file name includes a fragment index\n and possibly a durable marker, both of which which must be stripped off\n to retrieve the timestamp.\n\n :param filename: the file name including extension\n :returns: a dict, with keys for timestamp, frag_index, durable, ext and\n ctype_timestamp:\n\n * timestamp is a :class:`~swift.common.utils.Timestamp`\n * frag_index is an int or None\n * ctype_timestamp is a :class:`~swift.common.utils.Timestamp` or\n None for .meta files, otherwise None\n * ext is a string, the file extension including the leading dot or\n the empty string if the filename has no extension\n * durable is a boolean that is True if the filename is a data file\n that includes a durable marker\n\n :raises DiskFileError: if any part of the filename is not able to be\n validated.\n \"\"\"\n frag_index = None\n float_frag, ext = splitext(filename)\n if ext == '.data':\n parts = float_frag.split('#')\n try:\n timestamp = Timestamp(parts[0])\n except ValueError:\n raise DiskFileError('Invalid Timestamp value in filename %r'\n % filename)\n # it is an error for an EC data file to not have a valid\n # fragment index\n try:\n frag_index = parts[1]\n except IndexError:\n # expect validate_fragment_index raise DiskFileError\n pass\n frag_index = self.validate_fragment_index(frag_index)\n try:\n durable = parts[2] == 'd'\n except IndexError:\n durable = False\n return {\n 'timestamp': timestamp,\n 'frag_index': frag_index,\n 'ext': ext,\n 'ctype_timestamp': None,\n 'durable': durable\n }\n rv = super(ECDiskFileManager, self).parse_on_disk_filename(filename)\n rv['frag_index'] = None\n return rv\n\n def _process_ondisk_files(self, exts, results, frag_index=None,\n frag_prefs=None, **kwargs):\n \"\"\"\n Implement EC policy specific handling of .data and legacy .durable\n files.\n\n If a frag_prefs keyword arg is provided then its value may determine\n which fragment index at which timestamp is used to construct the\n diskfile. The value of frag_prefs should be a list. Each item in the\n frag_prefs list should be a dict that describes per-timestamp\n preferences using the following items:\n\n * timestamp: An instance of :class:`~swift.common.utils.Timestamp`.\n * exclude: A list of valid fragment indexes (i.e. whole numbers)\n that should be EXCLUDED when choosing a fragment at the\n timestamp. This list may be empty.\n\n For example::\n\n [\n {'timestamp': <Timestamp instance>, 'exclude': [1,3]},\n {'timestamp': <Timestamp instance>, 'exclude': []}\n ]\n\n The order of per-timestamp dicts in the frag_prefs list is significant\n and indicates descending preference for fragments from each timestamp\n i.e. a fragment that satisfies the first per-timestamp preference in\n the frag_prefs will be preferred over a fragment that satisfies a\n subsequent per-timestamp preferred, and so on.\n\n If a timestamp is not cited in any per-timestamp preference dict then\n it is assumed that any fragment index at that timestamp may be used to\n construct the diskfile.\n\n When a frag_prefs arg is provided, including an empty list, there is no\n requirement for there to be a durable file at the same timestamp as a\n data file that is chosen to construct the disk file\n\n :param exts: dict of lists of file info, keyed by extension\n :param results: a dict that may be updated with results\n :param frag_index: if set, search for a specific fragment index .data\n file, otherwise accept the first valid .data file.\n :param frag_prefs: if set, search for any fragment index .data file\n that satisfies the frag_prefs.\n \"\"\"\n durable_info = None\n if exts.get('.durable'):\n # in older versions, separate .durable files were used to indicate\n # the durability of data files having the same timestamp\n durable_info = exts['.durable'][0]\n\n # Split the list of .data files into sets of frags having the same\n # timestamp, identifying the durable and newest sets (if any) as we go.\n # To do this we can take advantage of the list of .data files being\n # reverse-time ordered. Keep the resulting per-timestamp frag sets in\n # a frag_sets dict mapping a Timestamp instance -> frag_set.\n all_frags = exts.get('.data')\n frag_sets = {}\n durable_frag_set = None\n while all_frags:\n frag_set, all_frags = self._split_gte_timestamp(\n all_frags, all_frags[0]['timestamp'])\n # sort the frag set into ascending frag_index order\n frag_set.sort(key=lambda info: info['frag_index'])\n timestamp = frag_set[0]['timestamp']\n frag_sets[timestamp] = frag_set\n for frag in frag_set:\n # a data file marked as durable may supersede a legacy durable\n # file if it is newer\n if frag['durable']:\n if (not durable_info or\n durable_info['timestamp'] < timestamp):\n # this frag defines the durable timestamp\n durable_info = frag\n break\n if durable_info and durable_info['timestamp'] == timestamp:\n durable_frag_set = frag_set\n break # ignore frags that are older than durable timestamp\n\n # Choose which frag set to use\n chosen_frag_set = None\n if frag_prefs is not None:\n candidate_frag_sets = dict(frag_sets)\n # For each per-timestamp frag preference dict, do we have any frag\n # indexes at that timestamp that are not in the exclusion list for\n # that timestamp? If so choose the highest of those frag_indexes.\n for ts, exclude_indexes in [\n (ts_pref['timestamp'], ts_pref['exclude'])\n for ts_pref in frag_prefs\n if ts_pref['timestamp'] in candidate_frag_sets]:\n available_indexes = [info['frag_index']\n for info in candidate_frag_sets[ts]]\n acceptable_indexes = list(set(available_indexes) -\n set(exclude_indexes))\n if acceptable_indexes:\n chosen_frag_set = candidate_frag_sets[ts]\n # override any frag_index passed in as method param with\n # the last (highest) acceptable_index\n frag_index = acceptable_indexes[-1]\n break\n else:\n # this frag_set has no acceptable frag index so\n # remove it from the candidate frag_sets\n candidate_frag_sets.pop(ts)\n else:\n # No acceptable frag index was found at any timestamp mentioned\n # in the frag_prefs. Choose the newest remaining candidate\n # frag_set - the proxy can decide if it wants the returned\n # fragment with that time.\n if candidate_frag_sets:\n ts_newest = sorted(candidate_frag_sets.keys())[-1]\n chosen_frag_set = candidate_frag_sets[ts_newest]\n else:\n chosen_frag_set = durable_frag_set\n\n # Select a single chosen frag from the chosen frag_set, by either\n # matching against a specified frag_index or taking the highest index.\n chosen_frag = None\n if chosen_frag_set:\n if frag_index is not None:\n # search the frag set to find the exact frag_index\n for info in chosen_frag_set:\n if info['frag_index'] == frag_index:\n chosen_frag = info\n break\n else:\n chosen_frag = chosen_frag_set[-1]\n\n # If we successfully found a frag then set results\n if chosen_frag:\n results['data_info'] = chosen_frag\n results['durable_frag_set'] = durable_frag_set\n results['chosen_frag_set'] = chosen_frag_set\n if chosen_frag_set != durable_frag_set:\n # hide meta files older than data file but newer than durable\n # file so they don't get marked as obsolete (we already threw\n # out .meta's that are older than a .durable)\n exts['.meta'], _older = self._split_gt_timestamp(\n exts['.meta'], chosen_frag['timestamp'])\n results['frag_sets'] = frag_sets\n\n # Mark everything older than most recent durable data as obsolete\n # and remove from the exts dict.\n if durable_info:\n for ext in exts.keys():\n exts[ext], older = self._split_gte_timestamp(\n exts[ext], durable_info['timestamp'])\n results.setdefault('obsolete', []).extend(older)\n\n # Mark any isolated legacy .durable as obsolete\n if exts.get('.durable') and not durable_frag_set:\n results.setdefault('obsolete', []).extend(exts['.durable'])\n exts.pop('.durable')\n\n # Fragments *may* be ready for reclaim, unless they are durable\n for frag_set in frag_sets.values():\n if frag_set in (durable_frag_set, chosen_frag_set):\n continue\n results.setdefault('possible_reclaim', []).extend(frag_set)\n\n # .meta files *may* be ready for reclaim if there is no durable data\n if exts.get('.meta') and not durable_frag_set:\n results.setdefault('possible_reclaim', []).extend(\n exts.get('.meta'))\n\n def _verify_ondisk_files(self, results, frag_index=None,\n frag_prefs=None, **kwargs):\n \"\"\"\n Verify that the final combination of on disk files complies with the\n erasure-coded diskfile contract.\n\n :param results: files that have been found and accepted\n :param frag_index: specifies a specific fragment index .data file\n :param frag_prefs: if set, indicates that fragment preferences have\n been specified and therefore that a selected fragment is not\n required to be durable.\n :returns: True if the file combination is compliant, False otherwise\n \"\"\"\n if super(ECDiskFileManager, self)._verify_ondisk_files(\n results, **kwargs):\n have_data_file = results['data_file'] is not None\n have_durable = (results.get('durable_frag_set') is not None or\n (have_data_file and frag_prefs is not None))\n return have_data_file == have_durable\n return False\n\n def _update_suffix_hashes(self, hashes, ondisk_info):\n \"\"\"\n Applies policy specific updates to the given dict of md5 hashes for\n the given ondisk_info.\n\n The only difference between this method and the replication policy\n function is the way that data files update hashes dict. Instead of all\n filenames hashed into a single hasher, each data file name will fall\n into a bucket keyed by its fragment index.\n\n :param hashes: a dict of md5 hashes to be updated\n :param ondisk_info: a dict describing the state of ondisk files, as\n returned by get_ondisk_files\n \"\"\"\n for frag_set in ondisk_info['frag_sets'].values():\n for file_info in frag_set:\n fi = file_info['frag_index']\n hashes[fi].update(file_info['timestamp'].internal)\n if 'durable_frag_set' in ondisk_info:\n # The durable_frag_set may be indicated by a legacy\n # <timestamp>.durable file or by a durable <timestamp>#fi#d.data\n # file. Either way we update hashes[None] with the string\n # <timestamp>.durable which is a consistent representation of the\n # abstract state of the object regardless of the actual file set.\n # That way if we use a local combination of a legacy t1.durable and\n # t1#0.data to reconstruct a remote t1#0#d.data then, when next\n # hashed, the local and remote will make identical updates to their\n # suffix hashes.\n file_info = ondisk_info['durable_frag_set'][0]\n hashes[None].update(file_info['timestamp'].internal + '.durable')\n\n def _hash_suffix(self, path):\n \"\"\"\n Performs reclamation and returns an md5 of all (remaining) files.\n\n :param path: full path to directory\n :raises PathNotDir: if given path is not a valid directory\n :raises OSError: for non-ENOTDIR errors\n :returns: dict of md5 hex digests\n \"\"\"\n # hash_per_fi instead of single hash for whole suffix\n # here we flatten out the hashers hexdigest into a dictionary instead\n # of just returning the one hexdigest for the whole suffix\n\n hash_per_fi = self._hash_suffix_dir(path)\n return dict((fi, md5.hexdigest()) for fi, md5 in hash_per_fi.items())\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227596,"cells":{"text":{"kind":"string","value":"# Copyright 2010 OpenStack Foundation\n# Copyright 2012 University Of Minho\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"); you may\n# not use this file except in compliance with the License. You may obtain\n# a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n# License for the specific language governing permissions and limitations\n# under the License.\n\nimport __builtin__\nimport contextlib\nimport copy\nimport datetime\nimport errno\nimport glob\nimport os\nimport random\nimport re\nimport shutil\nimport threading\nimport time\nimport uuid\n\nimport eventlet\nfrom eventlet import greenthread\nimport fixtures\nfrom lxml import etree\nimport mock\nfrom mox3 import mox\nfrom oslo_concurrency import lockutils\nfrom oslo_concurrency import processutils\nfrom oslo_config import cfg\nfrom oslo_serialization import jsonutils\nfrom oslo_utils import encodeutils\nfrom oslo_utils import importutils\nfrom oslo_utils import timeutils\nfrom oslo_utils import units\nimport six\n\nfrom nova.api.metadata import base as instance_metadata\nfrom nova.compute import arch\nfrom nova.compute import manager\nfrom nova.compute import power_state\nfrom nova.compute import task_states\nfrom nova.compute import utils as compute_utils\nfrom nova.compute import vm_mode\nfrom nova.compute import vm_states\nfrom nova import context\nfrom nova import db\nfrom nova import exception\nfrom nova.network import model as network_model\nfrom nova import objects\nfrom nova.openstack.common import fileutils\nfrom nova.openstack.common import loopingcall\nfrom nova.openstack.common import uuidutils\nfrom nova.pci import manager as pci_manager\nfrom nova import test\nfrom nova.tests.unit import fake_block_device\nfrom nova.tests.unit import fake_network\nimport nova.tests.unit.image.fake\nfrom nova.tests.unit import matchers\nfrom nova.tests.unit.objects import test_pci_device\nfrom nova.tests.unit.virt.libvirt import fake_imagebackend\nfrom nova.tests.unit.virt.libvirt import fake_libvirt_utils\nfrom nova.tests.unit.virt.libvirt import fakelibvirt\nfrom nova import utils\nfrom nova import version\nfrom nova.virt import block_device as driver_block_device\nfrom nova.virt import configdrive\nfrom nova.virt.disk import api as disk\nfrom nova.virt import driver\nfrom nova.virt import fake\nfrom nova.virt import firewall as base_firewall\nfrom nova.virt import hardware\nfrom nova.virt import images\nfrom nova.virt.libvirt import blockinfo\nfrom nova.virt.libvirt import config as vconfig\nfrom nova.virt.libvirt import driver as libvirt_driver\nfrom nova.virt.libvirt import firewall\nfrom nova.virt.libvirt import host\nfrom nova.virt.libvirt import imagebackend\nfrom nova.virt.libvirt import lvm\nfrom nova.virt.libvirt import rbd_utils\nfrom nova.virt.libvirt import utils as libvirt_utils\nfrom nova.virt.libvirt import volume as volume_drivers\n\ntry:\n import libvirt\nexcept ImportError:\n libvirt = fakelibvirt\nlibvirt_driver.libvirt = libvirt\nhost.libvirt = libvirt\n\n\nCONF = cfg.CONF\nCONF.import_opt('compute_manager', 'nova.service')\nCONF.import_opt('host', 'nova.netconf')\nCONF.import_opt('my_ip', 'nova.netconf')\nCONF.import_opt('image_cache_subdirectory_name', 'nova.virt.imagecache')\nCONF.import_opt('instances_path', 'nova.compute.manager')\n\n_fake_network_info = fake_network.fake_get_instance_nw_info\n\n_fake_NodeDevXml = \\\n {\"pci_0000_04_00_3\": \"\"\"\n <device>\n <name>pci_0000_04_00_3</name>\n <parent>pci_0000_00_01_1</parent>\n <driver>\n <name>igb</name>\n </driver>\n <capability type='pci'>\n <domain>0</domain>\n <bus>4</bus>\n <slot>0</slot>\n <function>3</function>\n <product id='0x1521'>I350 Gigabit Network Connection</product>\n <vendor id='0x8086'>Intel Corporation</vendor>\n <capability type='virt_functions'>\n <address domain='0x0000' bus='0x04' slot='0x10' function='0x3'/>\n <address domain='0x0000' bus='0x04' slot='0x10' function='0x7'/>\n <address domain='0x0000' bus='0x04' slot='0x11' function='0x3'/>\n <address domain='0x0000' bus='0x04' slot='0x11' function='0x7'/>\n </capability>\n </capability>\n </device>\"\"\",\n \"pci_0000_04_10_7\": \"\"\"\n <device>\n <name>pci_0000_04_10_7</name>\n <parent>pci_0000_00_01_1</parent>\n <driver>\n <name>igbvf</name>\n </driver>\n <capability type='pci'>\n <domain>0</domain>\n <bus>4</bus>\n <slot>16</slot>\n <function>7</function>\n <product id='0x1520'>I350 Ethernet Controller Virtual Function\n </product>\n <vendor id='0x8086'>Intel Corporation</vendor>\n <capability type='phys_function'>\n <address domain='0x0000' bus='0x04' slot='0x00' function='0x3'/>\n </capability>\n <capability type='virt_functions'>\n </capability>\n </capability>\n </device>\"\"\",\n \"pci_0000_04_11_7\": \"\"\"\n <device>\n <name>pci_0000_04_11_7</name>\n <parent>pci_0000_00_01_1</parent>\n <driver>\n <name>igbvf</name>\n </driver>\n <capability type='pci'>\n <domain>0</domain>\n <bus>4</bus>\n <slot>17</slot>\n <function>7</function>\n <product id='0x1520'>I350 Ethernet Controller Virtual Function\n </product>\n <vendor id='0x8086'>Intel Corporation</vendor>\n <numa node='0'/>\n <capability type='phys_function'>\n <address domain='0x0000' bus='0x04' slot='0x00' function='0x3'/>\n </capability>\n <capability type='virt_functions'>\n </capability>\n </capability>\n </device>\"\"\"}\n\n\ndef _concurrency(signal, wait, done, target, is_block_dev=False):\n signal.send()\n wait.wait()\n done.send()\n\n\nclass FakeVirDomainSnapshot(object):\n\n def __init__(self, dom=None):\n self.dom = dom\n\n def delete(self, flags):\n pass\n\n\nclass FakeVirtDomain(object):\n\n def __init__(self, fake_xml=None, uuidstr=None, id=None, name=None):\n if uuidstr is None:\n uuidstr = str(uuid.uuid4())\n self.uuidstr = uuidstr\n self.id = id\n self.domname = name\n self._info = [power_state.RUNNING, 2048 * units.Mi, 1234 * units.Mi,\n None, None]\n if fake_xml:\n self._fake_dom_xml = fake_xml\n else:\n self._fake_dom_xml = \"\"\"\n <domain type='kvm'>\n <devices>\n <disk type='file'>\n <source file='filename'/>\n </disk>\n </devices>\n </domain>\n \"\"\"\n\n def name(self):\n if self.domname is None:\n return \"fake-domain %s\" % self\n else:\n return self.domname\n\n def ID(self):\n return self.id\n\n def info(self):\n return self._info\n\n def create(self):\n pass\n\n def managedSave(self, *args):\n pass\n\n def createWithFlags(self, launch_flags):\n pass\n\n def XMLDesc(self, *args):\n return self._fake_dom_xml\n\n def UUIDString(self):\n return self.uuidstr\n\n def attachDeviceFlags(self, xml, flags):\n pass\n\n def attachDevice(self, xml):\n pass\n\n def detachDeviceFlags(self, xml, flags):\n pass\n\n def snapshotCreateXML(self, xml, flags):\n pass\n\n def blockCommit(self, disk, base, top, bandwidth=0, flags=0):\n pass\n\n def blockRebase(self, disk, base, bandwidth=0, flags=0):\n pass\n\n def blockJobInfo(self, path, flags):\n pass\n\n def resume(self):\n pass\n\n def destroy(self):\n pass\n\n def fsFreeze(self, disks=None, flags=0):\n pass\n\n def fsThaw(self, disks=None, flags=0):\n pass\n\n\nclass CacheConcurrencyTestCase(test.NoDBTestCase):\n def setUp(self):\n super(CacheConcurrencyTestCase, self).setUp()\n\n self.flags(instances_path=self.useFixture(fixtures.TempDir()).path)\n\n # utils.synchronized() will create the lock_path for us if it\n # doesn't already exist. It will also delete it when it's done,\n # which can cause race conditions with the multiple threads we\n # use for tests. So, create the path here so utils.synchronized()\n # won't delete it out from under one of the threads.\n self.lock_path = os.path.join(CONF.instances_path, 'locks')\n fileutils.ensure_tree(self.lock_path)\n\n def fake_exists(fname):\n basedir = os.path.join(CONF.instances_path,\n CONF.image_cache_subdirectory_name)\n if fname == basedir or fname == self.lock_path:\n return True\n return False\n\n def fake_execute(*args, **kwargs):\n pass\n\n def fake_extend(image, size, use_cow=False):\n pass\n\n self.stubs.Set(os.path, 'exists', fake_exists)\n self.stubs.Set(utils, 'execute', fake_execute)\n self.stubs.Set(imagebackend.disk, 'extend', fake_extend)\n self.useFixture(fixtures.MonkeyPatch(\n 'nova.virt.libvirt.imagebackend.libvirt_utils',\n fake_libvirt_utils))\n\n def test_same_fname_concurrency(self):\n # Ensures that the same fname cache runs at a sequentially.\n uuid = uuidutils.generate_uuid()\n\n backend = imagebackend.Backend(False)\n wait1 = eventlet.event.Event()\n done1 = eventlet.event.Event()\n sig1 = eventlet.event.Event()\n thr1 = eventlet.spawn(backend.image({'name': 'instance',\n 'uuid': uuid},\n 'name').cache,\n _concurrency, 'fname', None,\n signal=sig1, wait=wait1, done=done1)\n eventlet.sleep(0)\n # Thread 1 should run before thread 2.\n sig1.wait()\n\n wait2 = eventlet.event.Event()\n done2 = eventlet.event.Event()\n sig2 = eventlet.event.Event()\n thr2 = eventlet.spawn(backend.image({'name': 'instance',\n 'uuid': uuid},\n 'name').cache,\n _concurrency, 'fname', None,\n signal=sig2, wait=wait2, done=done2)\n\n wait2.send()\n eventlet.sleep(0)\n try:\n self.assertFalse(done2.ready())\n finally:\n wait1.send()\n done1.wait()\n eventlet.sleep(0)\n self.assertTrue(done2.ready())\n # Wait on greenthreads to assert they didn't raise exceptions\n # during execution\n thr1.wait()\n thr2.wait()\n\n def test_different_fname_concurrency(self):\n # Ensures that two different fname caches are concurrent.\n uuid = uuidutils.generate_uuid()\n\n backend = imagebackend.Backend(False)\n wait1 = eventlet.event.Event()\n done1 = eventlet.event.Event()\n sig1 = eventlet.event.Event()\n thr1 = eventlet.spawn(backend.image({'name': 'instance',\n 'uuid': uuid},\n 'name').cache,\n _concurrency, 'fname2', None,\n signal=sig1, wait=wait1, done=done1)\n eventlet.sleep(0)\n # Thread 1 should run before thread 2.\n sig1.wait()\n\n wait2 = eventlet.event.Event()\n done2 = eventlet.event.Event()\n sig2 = eventlet.event.Event()\n thr2 = eventlet.spawn(backend.image({'name': 'instance',\n 'uuid': uuid},\n 'name').cache,\n _concurrency, 'fname1', None,\n signal=sig2, wait=wait2, done=done2)\n eventlet.sleep(0)\n # Wait for thread 2 to start.\n sig2.wait()\n\n wait2.send()\n tries = 0\n while not done2.ready() and tries < 10:\n eventlet.sleep(0)\n tries += 1\n try:\n self.assertTrue(done2.ready())\n finally:\n wait1.send()\n eventlet.sleep(0)\n # Wait on greenthreads to assert they didn't raise exceptions\n # during execution\n thr1.wait()\n thr2.wait()\n\n\nclass FakeVolumeDriver(object):\n def __init__(self, *args, **kwargs):\n pass\n\n def attach_volume(self, *args):\n pass\n\n def detach_volume(self, *args):\n pass\n\n def get_xml(self, *args):\n return \"\"\n\n def get_config(self, *args):\n \"\"\"Connect the volume to a fake device.\"\"\"\n conf = vconfig.LibvirtConfigGuestDisk()\n conf.source_type = \"network\"\n conf.source_protocol = \"fake\"\n conf.source_name = \"fake\"\n conf.target_dev = \"fake\"\n conf.target_bus = \"fake\"\n return conf\n\n def connect_volume(self, *args):\n \"\"\"Connect the volume to a fake device.\"\"\"\n return self.get_config()\n\n\nclass FakeConfigGuestDisk(object):\n def __init__(self, *args, **kwargs):\n self.source_type = None\n self.driver_cache = None\n\n\nclass FakeConfigGuest(object):\n def __init__(self, *args, **kwargs):\n self.driver_cache = None\n\n\nclass FakeNodeDevice(object):\n def __init__(self, fakexml):\n self.xml = fakexml\n\n def XMLDesc(self, *args):\n return self.xml\n\n\nclass LibvirtConnTestCase(test.TestCase):\n\n REQUIRES_LOCKING = True\n\n _EPHEMERAL_20_DEFAULT = ('ephemeral_20_%s' %\n utils.get_hash_str(disk._DEFAULT_FILE_SYSTEM)[:7])\n\n def setUp(self):\n super(LibvirtConnTestCase, self).setUp()\n self.flags(fake_call=True)\n self.user_id = 'fake'\n self.project_id = 'fake'\n self.context = context.get_admin_context()\n temp_dir = self.useFixture(fixtures.TempDir()).path\n self.flags(instances_path=temp_dir)\n self.flags(snapshots_directory=temp_dir, group='libvirt')\n self.useFixture(fixtures.MonkeyPatch(\n 'nova.virt.libvirt.driver.libvirt_utils',\n fake_libvirt_utils))\n\n self.flags(sysinfo_serial=\"hardware\", group=\"libvirt\")\n\n self.useFixture(fixtures.MonkeyPatch(\n 'nova.virt.libvirt.imagebackend.libvirt_utils',\n fake_libvirt_utils))\n\n def fake_extend(image, size, use_cow=False):\n pass\n\n self.stubs.Set(libvirt_driver.disk, 'extend', fake_extend)\n\n self.stubs.Set(imagebackend.Image, 'resolve_driver_format',\n imagebackend.Image._get_driver_format)\n\n self.useFixture(fakelibvirt.FakeLibvirtFixture())\n\n flavor = objects.Flavor(memory_mb=2048,\n swap=0,\n vcpu_weight=None,\n root_gb=1,\n id=2,\n name=u'm1.small',\n ephemeral_gb=0,\n rxtx_factor=1.0,\n flavorid=u'1',\n vcpus=1)\n\n self.image_service = nova.tests.unit.image.fake.stub_out_image_service(\n self.stubs)\n self.test_instance = {\n 'id': 1,\n 'uuid': '32dfcb37-5af1-552b-357c-be8c3aa38310',\n 'memory_kb': '1024000',\n 'basepath': '/some/path',\n 'bridge_name': 'br100',\n 'display_name': \"Acme webserver\",\n 'vcpus': 2,\n 'project_id': 'fake',\n 'bridge': 'br101',\n 'image_ref': '155d900f-4e14-4e4c-a73d-069cbf4541e6',\n 'root_gb': 10,\n 'ephemeral_gb': 20,\n 'instance_type_id': '5', # m1.small\n 'extra_specs': {},\n 'system_metadata': {},\n 'flavor': flavor,\n 'new_flavor': None,\n 'old_flavor': None,\n 'pci_devices': objects.PciDeviceList(),\n 'numa_topology': None,\n 'config_drive': None,\n 'vm_mode': None,\n 'kernel_id': None,\n 'ramdisk_id': None,\n 'os_type': 'linux',\n 'user_id': '838a72b0-0d54-4827-8fd6-fb1227633ceb',\n 'ephemeral_key_uuid': None,\n }\n\n self.device_xml_tmpl = \"\"\"\n <domain type='kvm'>\n <devices>\n <disk type='block' device='disk'>\n <driver name='qemu' type='raw' cache='none'/>\n <source dev='{device_path}'/>\n <target bus='virtio' dev='vdb'/>\n <serial>58a84f6d-3f0c-4e19-a0af-eb657b790657</serial>\n <address type='pci' domain='0x0' bus='0x0' slot='0x04' \\\n function='0x0'/>\n </disk>\n </devices>\n </domain>\n \"\"\"\n\n def relpath(self, path):\n return os.path.relpath(path, CONF.instances_path)\n\n def tearDown(self):\n nova.tests.unit.image.fake.FakeImageService_reset()\n super(LibvirtConnTestCase, self).tearDown()\n\n def create_fake_libvirt_mock(self, **kwargs):\n \"\"\"Defining mocks for LibvirtDriver(libvirt is not used).\"\"\"\n\n # A fake libvirt.virConnect\n class FakeLibvirtDriver(object):\n def defineXML(self, xml):\n return FakeVirtDomain()\n\n # Creating mocks\n volume_driver = ('iscsi=nova.tests.unit.virt.libvirt.test_driver'\n '.FakeVolumeDriver')\n self.flags(volume_drivers=[volume_driver],\n group='libvirt')\n fake = FakeLibvirtDriver()\n # Customizing above fake if necessary\n for key, val in kwargs.items():\n fake.__setattr__(key, val)\n\n self.stubs.Set(libvirt_driver.LibvirtDriver, '_conn', fake)\n self.stubs.Set(host.Host, 'get_connection', lambda x: fake)\n\n def fake_lookup(self, instance_name):\n return FakeVirtDomain()\n\n def fake_execute(self, *args, **kwargs):\n open(args[-1], \"a\").close()\n\n def _create_service(self, **kwargs):\n service_ref = {'host': kwargs.get('host', 'dummy'),\n 'disabled': kwargs.get('disabled', False),\n 'binary': 'nova-compute',\n 'topic': 'compute',\n 'report_count': 0}\n\n return objects.Service(**service_ref)\n\n def _get_launch_flags(self, drvr, network_info, power_on=True,\n vifs_already_plugged=False):\n timeout = CONF.vif_plugging_timeout\n\n events = []\n if (drvr._conn_supports_start_paused and\n utils.is_neutron() and\n not vifs_already_plugged and\n power_on and timeout):\n events = drvr._get_neutron_events(network_info)\n\n launch_flags = events and libvirt.VIR_DOMAIN_START_PAUSED or 0\n\n return launch_flags\n\n def test_public_api_signatures(self):\n baseinst = driver.ComputeDriver(None)\n inst = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n self.assertPublicAPISignatures(baseinst, inst)\n\n def test_legacy_block_device_info(self):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n self.assertFalse(drvr.need_legacy_block_device_info)\n\n @mock.patch.object(host.Host, \"has_min_version\")\n def test_min_version_start_ok(self, mock_version):\n mock_version.return_value = True\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n drvr.init_host(\"dummyhost\")\n\n @mock.patch.object(host.Host, \"has_min_version\")\n def test_min_version_start_abort(self, mock_version):\n mock_version.return_value = False\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n self.assertRaises(exception.NovaException,\n drvr.init_host,\n \"dummyhost\")\n\n @mock.patch.object(objects.Service, 'get_by_compute_host')\n def test_set_host_enabled_with_disable(self, mock_svc):\n # Tests disabling an enabled host.\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n svc = self._create_service(host='fake-mini')\n mock_svc.return_value = svc\n drvr._set_host_enabled(False)\n self.assertTrue(svc.disabled)\n\n @mock.patch.object(objects.Service, 'get_by_compute_host')\n def test_set_host_enabled_with_enable(self, mock_svc):\n # Tests enabling a disabled host.\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n svc = self._create_service(disabled=True, host='fake-mini')\n mock_svc.return_value = svc\n drvr._set_host_enabled(True)\n self.assertTrue(svc.disabled)\n\n @mock.patch.object(objects.Service, 'get_by_compute_host')\n def test_set_host_enabled_with_enable_state_enabled(self, mock_svc):\n # Tests enabling an enabled host.\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n svc = self._create_service(disabled=False, host='fake-mini')\n mock_svc.return_value = svc\n drvr._set_host_enabled(True)\n self.assertFalse(svc.disabled)\n\n @mock.patch.object(objects.Service, 'get_by_compute_host')\n def test_set_host_enabled_with_disable_state_disabled(self, mock_svc):\n # Tests disabling a disabled host.\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n svc = self._create_service(disabled=True, host='fake-mini')\n mock_svc.return_value = svc\n drvr._set_host_enabled(False)\n self.assertTrue(svc.disabled)\n\n def test_set_host_enabled_swallows_exceptions(self):\n # Tests that set_host_enabled will swallow exceptions coming from the\n # db_api code so they don't break anything calling it, e.g. the\n # _get_new_connection method.\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n with mock.patch.object(db, 'service_get_by_compute_host') as db_mock:\n # Make db.service_get_by_compute_host raise NovaException; this\n # is more robust than just raising ComputeHostNotFound.\n db_mock.side_effect = exception.NovaException\n drvr._set_host_enabled(False)\n\n @mock.patch.object(fakelibvirt.virConnect, \"nodeDeviceLookupByName\")\n def test_prepare_pci_device(self, mock_lookup):\n\n pci_devices = [dict(hypervisor_name='xxx')]\n\n self.flags(virt_type='xen', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n conn = drvr._host.get_connection()\n\n mock_lookup.side_effect = lambda x: fakelibvirt.NodeDevice(conn)\n drvr._prepare_pci_devices_for_use(pci_devices)\n\n @mock.patch.object(fakelibvirt.virConnect, \"nodeDeviceLookupByName\")\n @mock.patch.object(fakelibvirt.virNodeDevice, \"dettach\")\n def test_prepare_pci_device_exception(self, mock_detach, mock_lookup):\n\n pci_devices = [dict(hypervisor_name='xxx',\n id='id1',\n instance_uuid='uuid')]\n\n self.flags(virt_type='xen', group='libvirt')\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n conn = drvr._host.get_connection()\n\n mock_lookup.side_effect = lambda x: fakelibvirt.NodeDevice(conn)\n mock_detach.side_effect = libvirt.libvirtError(\"xxxx\")\n\n self.assertRaises(exception.PciDevicePrepareFailed,\n drvr._prepare_pci_devices_for_use, pci_devices)\n\n def test_detach_pci_devices_exception(self):\n\n pci_devices = [dict(hypervisor_name='xxx',\n id='id1',\n instance_uuid='uuid')]\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n self.mox.StubOutWithMock(host.Host,\n 'has_min_version')\n host.Host.has_min_version = lambda x, y: False\n\n self.assertRaises(exception.PciDeviceDetachFailed,\n drvr._detach_pci_devices, None, pci_devices)\n\n def test_detach_pci_devices(self):\n\n fake_domXML1 =\\\n \"\"\"<domain> <devices>\n <disk type='file' device='disk'>\n <driver name='qemu' type='qcow2' cache='none'/>\n <source file='xxx'/>\n <target dev='vda' bus='virtio'/>\n <alias name='virtio-disk0'/>\n <address type='pci' domain='0x0000' bus='0x00'\n slot='0x04' function='0x0'/>\n </disk>\n <hostdev mode=\"subsystem\" type=\"pci\" managed=\"yes\">\n <source>\n <address function=\"0x1\" slot=\"0x10\" domain=\"0x0000\"\n bus=\"0x04\"/>\n </source>\n </hostdev></devices></domain>\"\"\"\n\n pci_devices = [dict(hypervisor_name='xxx',\n id='id1',\n instance_uuid='uuid',\n address=\"0001:04:10:1\")]\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n self.mox.StubOutWithMock(host.Host,\n 'has_min_version')\n host.Host.has_min_version = lambda x, y: True\n\n self.mox.StubOutWithMock(libvirt_driver.LibvirtDriver,\n '_get_guest_pci_device')\n\n class FakeDev(object):\n def to_xml(self):\n pass\n\n libvirt_driver.LibvirtDriver._get_guest_pci_device =\\\n lambda x, y: FakeDev()\n\n class FakeDomain(object):\n def detachDeviceFlags(self, xml, flag):\n pci_devices[0]['hypervisor_name'] = 'marked'\n pass\n\n def XMLDesc(self, flag):\n return fake_domXML1\n\n drvr._detach_pci_devices(FakeDomain(), pci_devices)\n self.assertEqual(pci_devices[0]['hypervisor_name'], 'marked')\n\n def test_detach_pci_devices_timeout(self):\n\n fake_domXML1 =\\\n \"\"\"<domain>\n <devices>\n <hostdev mode=\"subsystem\" type=\"pci\" managed=\"yes\">\n <source>\n <address function=\"0x1\" slot=\"0x10\" domain=\"0x0000\" bus=\"0x04\"/>\n </source>\n </hostdev>\n </devices>\n </domain>\"\"\"\n\n pci_devices = [dict(hypervisor_name='xxx',\n id='id1',\n instance_uuid='uuid',\n address=\"0000:04:10:1\")]\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n self.mox.StubOutWithMock(host.Host,\n 'has_min_version')\n host.Host.has_min_version = lambda x, y: True\n\n self.mox.StubOutWithMock(libvirt_driver.LibvirtDriver,\n '_get_guest_pci_device')\n\n class FakeDev(object):\n def to_xml(self):\n pass\n\n libvirt_driver.LibvirtDriver._get_guest_pci_device =\\\n lambda x, y: FakeDev()\n\n class FakeDomain(object):\n def detachDeviceFlags(self, xml, flag):\n pass\n\n def XMLDesc(self, flag):\n return fake_domXML1\n self.assertRaises(exception.PciDeviceDetachFailed,\n drvr._detach_pci_devices, FakeDomain(), pci_devices)\n\n def test_get_connector(self):\n initiator = 'fake.initiator.iqn'\n ip = 'fakeip'\n host = 'fakehost'\n wwpns = ['100010604b019419']\n wwnns = ['200010604b019419']\n self.flags(my_ip=ip)\n self.flags(host=host)\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n expected = {\n 'ip': ip,\n 'initiator': initiator,\n 'host': host,\n 'wwpns': wwpns,\n 'wwnns': wwnns\n }\n volume = {\n 'id': 'fake'\n }\n result = drvr.get_volume_connector(volume)\n self.assertThat(expected, matchers.DictMatches(result))\n\n def test_get_connector_storage_ip(self):\n ip = '100.100.100.100'\n storage_ip = '101.101.101.101'\n self.flags(my_block_storage_ip=storage_ip, my_ip=ip)\n volume = {\n 'id': 'fake'\n }\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n result = drvr.get_volume_connector(volume)\n self.assertEqual(storage_ip, result['ip'])\n\n def test_lifecycle_event_registration(self):\n calls = []\n\n def fake_registerErrorHandler(*args, **kwargs):\n calls.append('fake_registerErrorHandler')\n\n def fake_get_host_capabilities(**args):\n cpu = vconfig.LibvirtConfigGuestCPU()\n cpu.arch = arch.ARMV7\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = cpu\n calls.append('fake_get_host_capabilities')\n return caps\n\n @mock.patch.object(libvirt, 'registerErrorHandler',\n side_effect=fake_registerErrorHandler)\n @mock.patch.object(host.Host, \"get_capabilities\",\n side_effect=fake_get_host_capabilities)\n def test_init_host(get_host_capabilities, register_error_handler):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n drvr.init_host(\"test_host\")\n\n test_init_host()\n # NOTE(dkliban): Will fail if get_host_capabilities is called before\n # registerErrorHandler\n self.assertEqual(['fake_registerErrorHandler',\n 'fake_get_host_capabilities'], calls)\n\n def test_sanitize_log_to_xml(self):\n # setup fake data\n data = {'auth_password': 'scrubme'}\n bdm = [{'connection_info': {'data': data}}]\n bdi = {'block_device_mapping': bdm}\n\n # Tests that the parameters to the _get_guest_xml method\n # are sanitized for passwords when logged.\n def fake_debug(*args, **kwargs):\n if 'auth_password' in args[0]:\n self.assertNotIn('scrubme', args[0])\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n conf = mock.Mock()\n with contextlib.nested(\n mock.patch.object(libvirt_driver.LOG, 'debug',\n side_effect=fake_debug),\n mock.patch.object(drvr, '_get_guest_config', return_value=conf)\n ) as (\n debug_mock, conf_mock\n ):\n drvr._get_guest_xml(self.context, self.test_instance,\n network_info={}, disk_info={},\n image_meta={}, block_device_info=bdi)\n # we don't care what the log message is, we just want to make sure\n # our stub method is called which asserts the password is scrubbed\n self.assertTrue(debug_mock.called)\n\n @mock.patch.object(time, \"time\")\n def test_get_guest_config(self, time_mock):\n time_mock.return_value = 1234567.89\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n test_instance = copy.deepcopy(self.test_instance)\n test_instance[\"display_name\"] = \"purple tomatoes\"\n\n ctxt = context.RequestContext(project_id=123,\n project_name=\"aubergine\",\n user_id=456,\n user_name=\"pie\")\n\n flavor = objects.Flavor(name='m1.small',\n memory_mb=6,\n vcpus=28,\n root_gb=496,\n ephemeral_gb=8128,\n swap=33550336,\n extra_specs={})\n instance_ref = objects.Instance(**test_instance)\n image_meta = {}\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref,\n _fake_network_info(self.stubs, 1),\n {}, disk_info,\n context=ctxt, flavor=flavor)\n\n self.assertEqual(cfg.uuid, instance_ref[\"uuid\"])\n self.assertEqual(2, len(cfg.features))\n self.assertIsInstance(cfg.features[0],\n vconfig.LibvirtConfigGuestFeatureACPI)\n self.assertIsInstance(cfg.features[1],\n vconfig.LibvirtConfigGuestFeatureAPIC)\n self.assertEqual(cfg.memory, 6 * units.Ki)\n self.assertEqual(cfg.vcpus, 28)\n self.assertEqual(cfg.os_type, vm_mode.HVM)\n self.assertEqual(cfg.os_boot_dev, [\"hd\"])\n self.assertIsNone(cfg.os_root)\n self.assertEqual(len(cfg.devices), 9)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestInterface)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[8],\n vconfig.LibvirtConfigMemoryBalloon)\n self.assertEqual(len(cfg.metadata), 1)\n self.assertIsInstance(cfg.metadata[0],\n vconfig.LibvirtConfigGuestMetaNovaInstance)\n self.assertEqual(version.version_string_with_package(),\n cfg.metadata[0].package)\n self.assertEqual(\"purple tomatoes\",\n cfg.metadata[0].name)\n self.assertEqual(1234567.89,\n cfg.metadata[0].creationTime)\n self.assertEqual(\"image\",\n cfg.metadata[0].roottype)\n self.assertEqual(str(instance_ref[\"image_ref\"]),\n cfg.metadata[0].rootid)\n\n self.assertIsInstance(cfg.metadata[0].owner,\n vconfig.LibvirtConfigGuestMetaNovaOwner)\n self.assertEqual(456,\n cfg.metadata[0].owner.userid)\n self.assertEqual(\"pie\",\n cfg.metadata[0].owner.username)\n self.assertEqual(123,\n cfg.metadata[0].owner.projectid)\n self.assertEqual(\"aubergine\",\n cfg.metadata[0].owner.projectname)\n\n self.assertIsInstance(cfg.metadata[0].flavor,\n vconfig.LibvirtConfigGuestMetaNovaFlavor)\n self.assertEqual(\"m1.small\",\n cfg.metadata[0].flavor.name)\n self.assertEqual(6,\n cfg.metadata[0].flavor.memory)\n self.assertEqual(28,\n cfg.metadata[0].flavor.vcpus)\n self.assertEqual(496,\n cfg.metadata[0].flavor.disk)\n self.assertEqual(8128,\n cfg.metadata[0].flavor.ephemeral)\n self.assertEqual(33550336,\n cfg.metadata[0].flavor.swap)\n\n def test_get_guest_config_lxc(self):\n self.flags(virt_type='lxc', group='libvirt')\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n\n cfg = drvr._get_guest_config(instance_ref,\n _fake_network_info(self.stubs, 1),\n None, {'mapping': {}}, flavor=flavor)\n self.assertEqual(instance_ref[\"uuid\"], cfg.uuid)\n self.assertEqual(2 * units.Mi, cfg.memory)\n self.assertEqual(1, cfg.vcpus)\n self.assertEqual(vm_mode.EXE, cfg.os_type)\n self.assertEqual(\"/sbin/init\", cfg.os_init_path)\n self.assertEqual(\"console=tty0 console=ttyS0\", cfg.os_cmdline)\n self.assertIsNone(cfg.os_root)\n self.assertEqual(3, len(cfg.devices))\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestFilesys)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestInterface)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestConsole)\n\n def test_get_guest_config_lxc_with_id_maps(self):\n self.flags(virt_type='lxc', group='libvirt')\n self.flags(uid_maps=['0:1000:100'], group='libvirt')\n self.flags(gid_maps=['0:1000:100'], group='libvirt')\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n\n cfg = drvr._get_guest_config(instance_ref,\n _fake_network_info(self.stubs, 1),\n None, {'mapping': {}}, flavor=flavor)\n self.assertEqual(instance_ref[\"uuid\"], cfg.uuid)\n self.assertEqual(2 * units.Mi, cfg.memory)\n self.assertEqual(1, cfg.vcpus)\n self.assertEqual(vm_mode.EXE, cfg.os_type)\n self.assertEqual(\"/sbin/init\", cfg.os_init_path)\n self.assertEqual(\"console=tty0 console=ttyS0\", cfg.os_cmdline)\n self.assertIsNone(cfg.os_root)\n self.assertEqual(3, len(cfg.devices))\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestFilesys)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestInterface)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestConsole)\n self.assertEqual(len(cfg.idmaps), 2)\n self.assertIsInstance(cfg.idmaps[0],\n vconfig.LibvirtConfigGuestUIDMap)\n self.assertIsInstance(cfg.idmaps[1],\n vconfig.LibvirtConfigGuestGIDMap)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_numa_host_instance_fits(self, mock_flavor):\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = objects.Flavor(memory_mb=1, vcpus=2, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = self._fake_caps_numa_topology()\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n with contextlib.nested(\n mock.patch.object(host.Host, 'has_min_version',\n return_value=True),\n mock.patch.object(host.Host, \"get_capabilities\",\n return_value=caps),\n mock.patch.object(\n random, 'choice', side_effect=lambda cells: cells[0])):\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertEqual(set([0, 1]), cfg.cpuset)\n self.assertEqual(0, len(cfg.cputune.vcpupin))\n self.assertIsNone(cfg.cpu.numa)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_numa_host_instance_no_fit(self, mock_flavor):\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = objects.Flavor(memory_mb=4096, vcpus=4, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = self._fake_caps_numa_topology()\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n with contextlib.nested(\n mock.patch.object(host.Host, \"get_capabilities\",\n return_value=caps),\n mock.patch.object(\n hardware, 'get_vcpu_pin_set', return_value=set([3])),\n mock.patch.object(random, 'choice')\n ) as (get_host_cap_mock,\n get_vcpu_pin_set_mock, choice_mock):\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertFalse(choice_mock.called)\n self.assertEqual(set([3]), cfg.cpuset)\n self.assertEqual(0, len(cfg.cputune.vcpupin))\n self.assertIsNone(cfg.cpu.numa)\n\n def _test_get_guest_memory_backing_config(\n self, host_topology, inst_topology, numatune):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n with mock.patch.object(\n drvr, \"_get_host_numa_topology\",\n return_value=host_topology):\n return drvr._get_guest_memory_backing_config(\n inst_topology, numatune)\n\n @mock.patch.object(host.Host,\n 'has_min_version', return_value=True)\n def test_get_guest_memory_backing_config_large_success(self, mock_version):\n host_topology = objects.NUMATopology(\n cells=[\n objects.NUMACell(\n id=3, cpuset=set([1]), memory=1024, mempages=[\n objects.NUMAPagesTopology(size_kb=4, total=2000,\n used=0),\n objects.NUMAPagesTopology(size_kb=2048, total=512,\n used=0),\n objects.NUMAPagesTopology(size_kb=1048576, total=0,\n used=0),\n ])])\n inst_topology = objects.InstanceNUMATopology(cells=[\n objects.InstanceNUMACell(\n id=3, cpuset=set([0, 1]), memory=1024, pagesize=2048)])\n\n numa_tune = vconfig.LibvirtConfigGuestNUMATune()\n numa_tune.memnodes = [vconfig.LibvirtConfigGuestNUMATuneMemNode()]\n numa_tune.memnodes[0].cellid = 0\n numa_tune.memnodes[0].nodeset = [3]\n\n result = self._test_get_guest_memory_backing_config(\n host_topology, inst_topology, numa_tune)\n self.assertEqual(1, len(result.hugepages))\n self.assertEqual(2048, result.hugepages[0].size_kb)\n self.assertEqual([0], result.hugepages[0].nodeset)\n\n def test_get_guest_memory_backing_config_mempages_none(self):\n with mock.patch.object(host.Host, 'has_min_version',\n return_value=False):\n self.assertIsNone(self._test_get_guest_memory_backing_config(\n 'not_empty', 'not_empty', 'not_empty'))\n\n def test_get_guest_numa_tune_memnodes(self):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n guest_cpu_numa_config = objects.InstanceNUMATopology(cells=[\n objects.InstanceNUMACell(\n id=1, cpuset=set([0, 1]),\n memory=1024, pagesize=2048)])\n memnodes = [vconfig.LibvirtConfigGuestNUMATuneMemNode()]\n with mock.patch.object(host.Host, 'has_min_version',\n return_value=True):\n self.assertTrue(drvr._get_guest_numa_tune_memnodes(\n guest_cpu_numa_config, memnodes))\n self.assertEqual(guest_cpu_numa_config.cells[0].id,\n memnodes[0].cellid)\n\n def test_get_guest_numa_tune_memnodes_none(self):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n with mock.patch.object(host.Host, 'has_min_version',\n return_value=False):\n self.assertFalse(drvr._get_guest_numa_tune_memnodes(\n 'something', 'something'))\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_numa_host_instance_1pci_fits(self, mock_flavor):\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = objects.Flavor(memory_mb=1, vcpus=2, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = self._fake_caps_numa_topology()\n\n conn = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n pci_device_info = dict(test_pci_device.fake_db_dev)\n pci_device_info.update(compute_node_id=1,\n label='fake',\n status='available',\n address='0000:00:00.1',\n instance_uuid=None,\n request_id=None,\n extra_info={},\n numa_node=1)\n pci_device = objects.PciDevice(**pci_device_info)\n\n with contextlib.nested(\n mock.patch.object(host.Host, 'has_min_version',\n return_value=True),\n mock.patch.object(\n host.Host, \"get_capabilities\", return_value=caps),\n mock.patch.object(\n random, 'choice', side_effect=lambda cells: cells[0]),\n mock.patch.object(pci_manager, \"get_instance_pci_devs\",\n return_value=[pci_device])):\n cfg = conn._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertIsNone(instance_ref.numa_topology)\n self.assertEqual(set([2, 3]), cfg.cpuset)\n self.assertEqual(0, len(cfg.cputune.vcpupin))\n self.assertIsNone(cfg.cpu.numa)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_numa_host_instance_pci_no_numa_info(self,\n mock_flavor):\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = objects.Flavor(memory_mb=1, vcpus=2, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = self._fake_caps_numa_topology()\n\n conn = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n pci_device_info = dict(test_pci_device.fake_db_dev)\n pci_device_info.update(compute_node_id=1,\n label='fake',\n status='available',\n address='0000:00:00.1',\n instance_uuid=None,\n request_id=None,\n extra_info={},\n numa_node=None)\n pci_device = objects.PciDevice(**pci_device_info)\n\n with contextlib.nested(\n mock.patch.object(host.Host, 'has_min_version',\n return_value=True),\n mock.patch.object(\n host.Host, \"get_capabilities\", return_value=caps),\n mock.patch.object(\n hardware, 'get_vcpu_pin_set', return_value=set([3])),\n mock.patch.object(pci_manager, \"get_instance_pci_devs\",\n return_value=[pci_device])):\n cfg = conn._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertEqual(set([3]), cfg.cpuset)\n self.assertEqual(0, len(cfg.cputune.vcpupin))\n self.assertIsNone(cfg.cpu.numa)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_numa_host_instance_2pci_no_fit(self,\n mock_flavor):\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = objects.Flavor(memory_mb=4096, vcpus=4, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = self._fake_caps_numa_topology()\n\n conn = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n pci_device_info = dict(test_pci_device.fake_db_dev)\n pci_device_info.update(compute_node_id=1,\n label='fake',\n status='available',\n address='0000:00:00.1',\n instance_uuid=None,\n request_id=None,\n extra_info={},\n numa_node=1)\n pci_device = objects.PciDevice(**pci_device_info)\n pci_device_info.update(numa_node=0, address='0000:00:00.2')\n pci_device2 = objects.PciDevice(**pci_device_info)\n with contextlib.nested(\n mock.patch.object(\n host.Host, \"get_capabilities\", return_value=caps),\n mock.patch.object(\n hardware, 'get_vcpu_pin_set', return_value=set([3])),\n mock.patch.object(random, 'choice'),\n mock.patch.object(pci_manager, \"get_instance_pci_devs\",\n return_value=[pci_device, pci_device2])\n ) as (get_host_cap_mock,\n get_vcpu_pin_set_mock, choice_mock, pci_mock):\n cfg = conn._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertFalse(choice_mock.called)\n self.assertEqual(set([3]), cfg.cpuset)\n self.assertEqual(0, len(cfg.cputune.vcpupin))\n self.assertIsNone(cfg.cpu.numa)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_numa_empty_memnode(self, mock_flavor):\n instance_topology = objects.InstanceNUMATopology(\n cells=[objects.InstanceNUMACell(\n id=0, cpuset=set([0]), memory=1024)])\n instance_ref = objects.Instance(**self.test_instance)\n instance_ref.numa_topology = instance_topology\n image_meta = {}\n flavor = objects.Flavor(memory_mb=1, vcpus=2, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = self._fake_caps_numa_topology()\n\n def fake_has_min_version(ver):\n if ver == libvirt_driver.MIN_LIBVIRT_MEMNODE_VERSION:\n return False\n return True\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n with contextlib.nested(\n mock.patch.object(host.Host, 'has_min_version',\n side_effect=fake_has_min_version),\n mock.patch.object(host.Host, \"get_capabilities\",\n return_value=caps),\n mock.patch.object(\n random, 'choice', side_effect=lambda cells: cells[0])):\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertFalse(cfg.numatune.memnodes)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_numa_host_instance_fit_w_cpu_pinset(self,\n mock_flavor):\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = objects.Flavor(memory_mb=1024, vcpus=2, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = self._fake_caps_numa_topology()\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n with contextlib.nested(\n mock.patch.object(host.Host, 'has_min_version',\n return_value=True),\n mock.patch.object(host.Host, \"get_capabilities\",\n return_value=caps),\n mock.patch.object(\n hardware, 'get_vcpu_pin_set', return_value=set([2, 3])),\n mock.patch.object(\n random, 'choice', side_effect=lambda cells: cells[0])\n ) as (has_min_version_mock, get_host_cap_mock,\n get_vcpu_pin_set_mock, choice_mock):\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n # NOTE(ndipanov): we make sure that pin_set was taken into account\n # when choosing viable cells\n choice_mock.assert_called_once_with([set([2, 3])])\n self.assertEqual(set([2, 3]), cfg.cpuset)\n self.assertEqual(0, len(cfg.cputune.vcpupin))\n self.assertIsNone(cfg.cpu.numa)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_non_numa_host_instance_topo(self, mock_flavor):\n instance_topology = objects.InstanceNUMATopology(\n cells=[objects.InstanceNUMACell(\n id=0, cpuset=set([0]), memory=1024),\n objects.InstanceNUMACell(\n id=1, cpuset=set([2]), memory=1024)])\n instance_ref = objects.Instance(**self.test_instance)\n instance_ref.numa_topology = instance_topology\n image_meta = {}\n flavor = objects.Flavor(memory_mb=2048, vcpus=2, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = None\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n with contextlib.nested(\n mock.patch.object(\n objects.InstanceNUMATopology, \"get_by_instance_uuid\",\n return_value=instance_topology),\n mock.patch.object(host.Host, 'has_min_version',\n return_value=True),\n mock.patch.object(host.Host, \"get_capabilities\",\n return_value=caps)):\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertIsNone(cfg.cpuset)\n self.assertEqual(0, len(cfg.cputune.vcpupin))\n self.assertIsNone(cfg.numatune)\n self.assertIsNotNone(cfg.cpu.numa)\n for instance_cell, numa_cfg_cell in zip(\n instance_topology.cells, cfg.cpu.numa.cells):\n self.assertEqual(instance_cell.id, numa_cfg_cell.id)\n self.assertEqual(instance_cell.cpuset, numa_cfg_cell.cpus)\n self.assertEqual(instance_cell.memory * units.Ki,\n numa_cfg_cell.memory)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_numa_host_instance_topo(self, mock_flavor):\n instance_topology = objects.InstanceNUMATopology(\n cells=[objects.InstanceNUMACell(\n id=1, cpuset=set([0, 1]), memory=1024, pagesize=None),\n objects.InstanceNUMACell(\n id=2, cpuset=set([2, 3]), memory=1024,\n pagesize=None)])\n instance_ref = objects.Instance(**self.test_instance)\n instance_ref.numa_topology = instance_topology\n image_meta = {}\n flavor = objects.Flavor(memory_mb=2048, vcpus=4, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = self._fake_caps_numa_topology()\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n with contextlib.nested(\n mock.patch.object(\n objects.Flavor, \"get_by_id\", return_value=flavor),\n mock.patch.object(\n objects.InstanceNUMATopology, \"get_by_instance_uuid\",\n return_value=instance_topology),\n mock.patch.object(host.Host, 'has_min_version',\n return_value=True),\n mock.patch.object(host.Host, \"get_capabilities\",\n return_value=caps),\n mock.patch.object(\n hardware, 'get_vcpu_pin_set',\n return_value=set([2, 3, 4, 5]))\n ):\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertIsNone(cfg.cpuset)\n # Test that the pinning is correct and limited to allowed only\n self.assertEqual(0, cfg.cputune.vcpupin[0].id)\n self.assertEqual(set([2, 3]), cfg.cputune.vcpupin[0].cpuset)\n self.assertEqual(1, cfg.cputune.vcpupin[1].id)\n self.assertEqual(set([2, 3]), cfg.cputune.vcpupin[1].cpuset)\n self.assertEqual(2, cfg.cputune.vcpupin[2].id)\n self.assertEqual(set([4, 5]), cfg.cputune.vcpupin[2].cpuset)\n self.assertEqual(3, cfg.cputune.vcpupin[3].id)\n self.assertEqual(set([4, 5]), cfg.cputune.vcpupin[3].cpuset)\n self.assertIsNotNone(cfg.cpu.numa)\n\n self.assertIsInstance(cfg.cputune.emulatorpin,\n vconfig.LibvirtConfigGuestCPUTuneEmulatorPin)\n self.assertEqual(set([2, 3, 4, 5]), cfg.cputune.emulatorpin.cpuset)\n\n for instance_cell, numa_cfg_cell, index in zip(\n instance_topology.cells,\n cfg.cpu.numa.cells,\n range(len(instance_topology.cells))):\n self.assertEqual(index, numa_cfg_cell.id)\n self.assertEqual(instance_cell.cpuset, numa_cfg_cell.cpus)\n self.assertEqual(instance_cell.memory * units.Ki,\n numa_cfg_cell.memory)\n\n allnodes = [cell.id for cell in instance_topology.cells]\n self.assertEqual(allnodes, cfg.numatune.memory.nodeset)\n self.assertEqual(\"strict\", cfg.numatune.memory.mode)\n\n for instance_cell, memnode, index in zip(\n instance_topology.cells,\n cfg.numatune.memnodes,\n range(len(instance_topology.cells))):\n self.assertEqual(index, memnode.cellid)\n self.assertEqual([instance_cell.id], memnode.nodeset)\n self.assertEqual(\"strict\", memnode.mode)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_numa_host_instance_topo_reordered(self,\n mock_flavor):\n instance_topology = objects.InstanceNUMATopology(\n cells=[objects.InstanceNUMACell(\n id=3, cpuset=set([0, 1]), memory=1024),\n objects.InstanceNUMACell(\n id=0, cpuset=set([2, 3]), memory=1024)])\n instance_ref = objects.Instance(**self.test_instance)\n instance_ref.numa_topology = instance_topology\n image_meta = {}\n flavor = objects.Flavor(memory_mb=2048, vcpus=4, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = self._fake_caps_numa_topology()\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n with contextlib.nested(\n mock.patch.object(\n objects.Flavor, \"get_by_id\", return_value=flavor),\n mock.patch.object(\n objects.InstanceNUMATopology, \"get_by_instance_uuid\",\n return_value=instance_topology),\n mock.patch.object(host.Host, 'has_min_version',\n return_value=True),\n mock.patch.object(host.Host, \"get_capabilities\",\n return_value=caps),\n ):\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertIsNone(cfg.cpuset)\n # Test that the pinning is correct and limited to allowed only\n self.assertEqual(0, cfg.cputune.vcpupin[0].id)\n self.assertEqual(set([6, 7]), cfg.cputune.vcpupin[0].cpuset)\n self.assertEqual(1, cfg.cputune.vcpupin[1].id)\n self.assertEqual(set([6, 7]), cfg.cputune.vcpupin[1].cpuset)\n self.assertEqual(2, cfg.cputune.vcpupin[2].id)\n self.assertEqual(set([0, 1]), cfg.cputune.vcpupin[2].cpuset)\n self.assertEqual(3, cfg.cputune.vcpupin[3].id)\n self.assertEqual(set([0, 1]), cfg.cputune.vcpupin[3].cpuset)\n self.assertIsNotNone(cfg.cpu.numa)\n\n self.assertIsInstance(cfg.cputune.emulatorpin,\n vconfig.LibvirtConfigGuestCPUTuneEmulatorPin)\n self.assertEqual(set([0, 1, 6, 7]), cfg.cputune.emulatorpin.cpuset)\n\n for index, (instance_cell, numa_cfg_cell) in enumerate(zip(\n instance_topology.cells,\n cfg.cpu.numa.cells)):\n self.assertEqual(index, numa_cfg_cell.id)\n self.assertEqual(instance_cell.cpuset, numa_cfg_cell.cpus)\n self.assertEqual(instance_cell.memory * units.Ki,\n numa_cfg_cell.memory)\n\n allnodes = set([cell.id for cell in instance_topology.cells])\n self.assertEqual(allnodes, set(cfg.numatune.memory.nodeset))\n self.assertEqual(\"strict\", cfg.numatune.memory.mode)\n\n for index, (instance_cell, memnode) in enumerate(zip(\n instance_topology.cells,\n cfg.numatune.memnodes)):\n self.assertEqual(index, memnode.cellid)\n self.assertEqual([instance_cell.id], memnode.nodeset)\n self.assertEqual(\"strict\", memnode.mode)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_numa_host_instance_topo_cpu_pinning(self,\n mock_flavor):\n instance_topology = objects.InstanceNUMATopology(\n cells=[objects.InstanceNUMACell(\n id=1, cpuset=set([0, 1]), memory=1024,\n cpu_pinning={0: 3, 1: 2}),\n objects.InstanceNUMACell(\n id=0, cpuset=set([2, 3]), memory=1024,\n cpu_pinning={2: 0, 3: 1})])\n instance_ref = objects.Instance(**self.test_instance)\n instance_ref.numa_topology = instance_topology\n image_meta = {}\n flavor = objects.Flavor(memory_mb=2048, vcpus=2, root_gb=496,\n ephemeral_gb=8128, swap=33550336, name='fake',\n extra_specs={})\n mock_flavor.return_value = flavor\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = vconfig.LibvirtConfigCPU()\n caps.host.cpu.arch = \"x86_64\"\n caps.host.topology = self._fake_caps_numa_topology()\n\n conn = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n with contextlib.nested(\n mock.patch.object(\n objects.InstanceNUMATopology, \"get_by_instance_uuid\",\n return_value=instance_topology),\n mock.patch.object(host.Host, 'has_min_version',\n return_value=True),\n mock.patch.object(host.Host, \"get_capabilities\",\n return_value=caps)\n ):\n cfg = conn._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertIsNone(cfg.cpuset)\n # Test that the pinning is correct and limited to allowed only\n self.assertEqual(0, cfg.cputune.vcpupin[0].id)\n self.assertEqual(set([3]), cfg.cputune.vcpupin[0].cpuset)\n self.assertEqual(1, cfg.cputune.vcpupin[1].id)\n self.assertEqual(set([2]), cfg.cputune.vcpupin[1].cpuset)\n self.assertEqual(2, cfg.cputune.vcpupin[2].id)\n self.assertEqual(set([0]), cfg.cputune.vcpupin[2].cpuset)\n self.assertEqual(3, cfg.cputune.vcpupin[3].id)\n self.assertEqual(set([1]), cfg.cputune.vcpupin[3].cpuset)\n self.assertIsNotNone(cfg.cpu.numa)\n\n self.assertIsInstance(cfg.cputune.emulatorpin,\n vconfig.LibvirtConfigGuestCPUTuneEmulatorPin)\n self.assertEqual(set([0, 1, 2, 3]), cfg.cputune.emulatorpin.cpuset)\n\n for i, (instance_cell, numa_cfg_cell) in enumerate(zip(\n instance_topology.cells, cfg.cpu.numa.cells)):\n self.assertEqual(i, numa_cfg_cell.id)\n self.assertEqual(instance_cell.cpuset, numa_cfg_cell.cpus)\n self.assertEqual(instance_cell.memory * units.Ki,\n numa_cfg_cell.memory)\n\n allnodes = set([cell.id for cell in instance_topology.cells])\n self.assertEqual(allnodes, set(cfg.numatune.memory.nodeset))\n self.assertEqual(\"strict\", cfg.numatune.memory.mode)\n\n for i, (instance_cell, memnode) in enumerate(zip(\n instance_topology.cells, cfg.numatune.memnodes)):\n self.assertEqual(i, memnode.cellid)\n self.assertEqual([instance_cell.id], memnode.nodeset)\n self.assertEqual(\"strict\", memnode.mode)\n\n def test_get_cpu_numa_config_from_instance(self):\n topology = objects.InstanceNUMATopology(cells=[\n objects.InstanceNUMACell(id=0, cpuset=set([1, 2]), memory=128),\n objects.InstanceNUMACell(id=1, cpuset=set([3, 4]), memory=128),\n ])\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n conf = drvr._get_cpu_numa_config_from_instance(topology)\n\n self.assertIsInstance(conf, vconfig.LibvirtConfigGuestCPUNUMA)\n self.assertEqual(0, conf.cells[0].id)\n self.assertEqual(set([1, 2]), conf.cells[0].cpus)\n self.assertEqual(131072, conf.cells[0].memory)\n self.assertEqual(1, conf.cells[1].id)\n self.assertEqual(set([3, 4]), conf.cells[1].cpus)\n self.assertEqual(131072, conf.cells[1].memory)\n\n def test_get_cpu_numa_config_from_instance_none(self):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n conf = drvr._get_cpu_numa_config_from_instance(None)\n self.assertIsNone(conf)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_clock(self, mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n image_meta = {}\n hpet_map = {\n arch.X86_64: True,\n arch.I686: True,\n arch.PPC: False,\n arch.PPC64: False,\n arch.ARMV7: False,\n arch.AARCH64: False,\n }\n\n for guestarch, expect_hpet in hpet_map.items():\n with mock.patch.object(libvirt_driver.libvirt_utils,\n 'get_arch',\n return_value=guestarch):\n cfg = drvr._get_guest_config(instance_ref, [],\n image_meta,\n disk_info)\n self.assertIsInstance(cfg.clock,\n vconfig.LibvirtConfigGuestClock)\n self.assertEqual(cfg.clock.offset, \"utc\")\n self.assertIsInstance(cfg.clock.timers[0],\n vconfig.LibvirtConfigGuestTimer)\n self.assertIsInstance(cfg.clock.timers[1],\n vconfig.LibvirtConfigGuestTimer)\n self.assertEqual(cfg.clock.timers[0].name, \"pit\")\n self.assertEqual(cfg.clock.timers[0].tickpolicy,\n \"delay\")\n self.assertEqual(cfg.clock.timers[1].name, \"rtc\")\n self.assertEqual(cfg.clock.timers[1].tickpolicy,\n \"catchup\")\n if expect_hpet:\n self.assertEqual(3, len(cfg.clock.timers))\n self.assertIsInstance(cfg.clock.timers[2],\n vconfig.LibvirtConfigGuestTimer)\n self.assertEqual('hpet', cfg.clock.timers[2].name)\n self.assertFalse(cfg.clock.timers[2].present)\n else:\n self.assertEqual(2, len(cfg.clock.timers))\n\n @mock.patch.object(libvirt_utils, 'get_arch')\n @mock.patch.object(host.Host, 'has_min_version')\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_windows(self, mock_flavor, mock_version,\n mock_get_arch):\n mock_version.return_value = False\n mock_get_arch.return_value = arch.I686\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n instance_ref['os_type'] = 'windows'\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref,\n _fake_network_info(self.stubs, 1),\n {}, disk_info)\n\n self.assertIsInstance(cfg.clock,\n vconfig.LibvirtConfigGuestClock)\n self.assertEqual(cfg.clock.offset, \"localtime\")\n\n self.assertEqual(3, len(cfg.clock.timers), cfg.clock.timers)\n self.assertEqual(\"pit\", cfg.clock.timers[0].name)\n self.assertEqual(\"rtc\", cfg.clock.timers[1].name)\n self.assertEqual(\"hpet\", cfg.clock.timers[2].name)\n self.assertFalse(cfg.clock.timers[2].present)\n\n @mock.patch.object(libvirt_utils, 'get_arch')\n @mock.patch.object(host.Host, 'has_min_version')\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_windows_timer(self, mock_flavor, mock_version,\n mock_get_arch):\n mock_version.return_value = True\n mock_get_arch.return_value = arch.I686\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n instance_ref['os_type'] = 'windows'\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref,\n _fake_network_info(self.stubs, 1),\n {}, disk_info)\n\n self.assertIsInstance(cfg.clock,\n vconfig.LibvirtConfigGuestClock)\n self.assertEqual(cfg.clock.offset, \"localtime\")\n\n self.assertEqual(4, len(cfg.clock.timers), cfg.clock.timers)\n self.assertEqual(\"pit\", cfg.clock.timers[0].name)\n self.assertEqual(\"rtc\", cfg.clock.timers[1].name)\n self.assertEqual(\"hpet\", cfg.clock.timers[2].name)\n self.assertFalse(cfg.clock.timers[2].present)\n self.assertEqual(\"hypervclock\", cfg.clock.timers[3].name)\n self.assertTrue(cfg.clock.timers[3].present)\n\n self.assertEqual(3, len(cfg.features))\n self.assertIsInstance(cfg.features[0],\n vconfig.LibvirtConfigGuestFeatureACPI)\n self.assertIsInstance(cfg.features[1],\n vconfig.LibvirtConfigGuestFeatureAPIC)\n self.assertIsInstance(cfg.features[2],\n vconfig.LibvirtConfigGuestFeatureHyperV)\n\n @mock.patch.object(host.Host, 'has_min_version')\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_windows_hyperv_feature1(self,\n mock_flavor,\n mock_version):\n def fake_version(lv_ver=None, hv_ver=None, hv_type=None):\n if lv_ver == (1, 0, 0) and hv_ver == (1, 1, 0):\n return True\n return False\n\n mock_version.side_effect = fake_version\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n instance_ref['os_type'] = 'windows'\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref,\n _fake_network_info(self.stubs, 1),\n {}, disk_info)\n\n self.assertIsInstance(cfg.clock,\n vconfig.LibvirtConfigGuestClock)\n self.assertEqual(cfg.clock.offset, \"localtime\")\n\n self.assertEqual(3, len(cfg.features))\n self.assertIsInstance(cfg.features[0],\n vconfig.LibvirtConfigGuestFeatureACPI)\n self.assertIsInstance(cfg.features[1],\n vconfig.LibvirtConfigGuestFeatureAPIC)\n self.assertIsInstance(cfg.features[2],\n vconfig.LibvirtConfigGuestFeatureHyperV)\n\n self.assertTrue(cfg.features[2].relaxed)\n self.assertFalse(cfg.features[2].spinlocks)\n self.assertFalse(cfg.features[2].vapic)\n\n @mock.patch.object(host.Host, 'has_min_version')\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_windows_hyperv_feature2(self,\n mock_flavor,\n mock_version):\n mock_version.return_value = True\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n instance_ref['os_type'] = 'windows'\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref,\n _fake_network_info(self.stubs, 1),\n {}, disk_info)\n\n self.assertIsInstance(cfg.clock,\n vconfig.LibvirtConfigGuestClock)\n self.assertEqual(cfg.clock.offset, \"localtime\")\n\n self.assertEqual(3, len(cfg.features))\n self.assertIsInstance(cfg.features[0],\n vconfig.LibvirtConfigGuestFeatureACPI)\n self.assertIsInstance(cfg.features[1],\n vconfig.LibvirtConfigGuestFeatureAPIC)\n self.assertIsInstance(cfg.features[2],\n vconfig.LibvirtConfigGuestFeatureHyperV)\n\n self.assertTrue(cfg.features[2].relaxed)\n self.assertTrue(cfg.features[2].spinlocks)\n self.assertEqual(8191, cfg.features[2].spinlock_retries)\n self.assertTrue(cfg.features[2].vapic)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_two_nics(self, mock_flavor):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref,\n _fake_network_info(self.stubs, 2),\n {}, disk_info)\n self.assertEqual(2, len(cfg.features))\n self.assertIsInstance(cfg.features[0],\n vconfig.LibvirtConfigGuestFeatureACPI)\n self.assertIsInstance(cfg.features[1],\n vconfig.LibvirtConfigGuestFeatureAPIC)\n self.assertEqual(cfg.memory, 2 * units.Mi)\n self.assertEqual(cfg.vcpus, 1)\n self.assertEqual(cfg.os_type, vm_mode.HVM)\n self.assertEqual(cfg.os_boot_dev, [\"hd\"])\n self.assertIsNone(cfg.os_root)\n self.assertEqual(len(cfg.devices), 10)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestInterface)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestInterface)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[8],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[9],\n vconfig.LibvirtConfigMemoryBalloon)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_bug_1118829(self, mock_flavor):\n self.flags(virt_type='uml', group='libvirt')\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = {'disk_bus': 'virtio',\n 'cdrom_bus': 'ide',\n 'mapping': {u'vda': {'bus': 'virtio',\n 'type': 'disk',\n 'dev': u'vda'},\n 'root': {'bus': 'virtio',\n 'type': 'disk',\n 'dev': 'vda'}}}\n\n # NOTE(jdg): For this specific test leave this blank\n # This will exercise the failed code path still,\n # and won't require fakes and stubs of the iscsi discovery\n block_device_info = {}\n drvr._get_guest_config(instance_ref, [], {}, disk_info,\n None, block_device_info)\n self.assertEqual(instance_ref['root_device_name'], '/dev/vda')\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_root_device_name(self, mock_flavor):\n self.flags(virt_type='uml', group='libvirt')\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n block_device_info = {'root_device_name': '/dev/vdb'}\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta,\n block_device_info)\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info,\n None, block_device_info)\n self.assertEqual(0, len(cfg.features))\n self.assertEqual(cfg.memory, 2 * units.Mi)\n self.assertEqual(cfg.vcpus, 1)\n self.assertEqual(cfg.os_type, \"uml\")\n self.assertEqual(cfg.os_boot_dev, [])\n self.assertEqual(cfg.os_root, '/dev/vdb')\n self.assertEqual(len(cfg.devices), 3)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestConsole)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_block_device(self, mock_flavor):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n conn_info = {'driver_volume_type': 'fake'}\n info = {'block_device_mapping': driver_block_device.convert_volumes([\n fake_block_device.FakeDbBlockDeviceDict(\n {'id': 1,\n 'source_type': 'volume', 'destination_type': 'volume',\n 'device_name': '/dev/vdc'}),\n fake_block_device.FakeDbBlockDeviceDict(\n {'id': 2,\n 'source_type': 'volume', 'destination_type': 'volume',\n 'device_name': '/dev/vdd'}),\n ])}\n info['block_device_mapping'][0]['connection_info'] = conn_info\n info['block_device_mapping'][1]['connection_info'] = conn_info\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta,\n info)\n with mock.patch.object(\n driver_block_device.DriverVolumeBlockDevice, 'save'\n ) as mock_save:\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info,\n None, info)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestDisk)\n self.assertEqual(cfg.devices[2].target_dev, 'vdc')\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestDisk)\n self.assertEqual(cfg.devices[3].target_dev, 'vdd')\n mock_save.assert_called_with()\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_lxc_with_attached_volume(self, mock_flavor):\n self.flags(virt_type='lxc', group='libvirt')\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n conn_info = {'driver_volume_type': 'fake'}\n info = {'block_device_mapping': driver_block_device.convert_volumes([\n fake_block_device.FakeDbBlockDeviceDict(\n {'id': 1,\n 'source_type': 'volume', 'destination_type': 'volume',\n 'boot_index': 0}),\n fake_block_device.FakeDbBlockDeviceDict(\n {'id': 2,\n 'source_type': 'volume', 'destination_type': 'volume',\n }),\n fake_block_device.FakeDbBlockDeviceDict(\n {'id': 3,\n 'source_type': 'volume', 'destination_type': 'volume',\n }),\n ])}\n\n info['block_device_mapping'][0]['connection_info'] = conn_info\n info['block_device_mapping'][1]['connection_info'] = conn_info\n info['block_device_mapping'][2]['connection_info'] = conn_info\n info['block_device_mapping'][0]['mount_device'] = '/dev/vda'\n info['block_device_mapping'][1]['mount_device'] = '/dev/vdc'\n info['block_device_mapping'][2]['mount_device'] = '/dev/vdd'\n with mock.patch.object(\n driver_block_device.DriverVolumeBlockDevice, 'save'\n ) as mock_save:\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta,\n info)\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info,\n None, info)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertEqual(cfg.devices[1].target_dev, 'vdc')\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestDisk)\n self.assertEqual(cfg.devices[2].target_dev, 'vdd')\n mock_save.assert_called_with()\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_configdrive(self, mock_flavor):\n # It's necessary to check if the architecture is power, because\n # power doesn't have support to ide, and so libvirt translate\n # all ide calls to scsi\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n # make configdrive.required_by() return True\n instance_ref['config_drive'] = True\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n\n # The last device is selected for this. on x86 is the last ide\n # device (hdd). Since power only support scsi, the last device\n # is sdz\n\n expect = {\"ppc\": \"sdz\", \"ppc64\": \"sdz\"}\n disk = expect.get(blockinfo.libvirt_utils.get_arch({}), \"hdd\")\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestDisk)\n self.assertEqual(cfg.devices[2].target_dev, disk)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_virtio_scsi_bus(self, mock_flavor):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n image_meta = {\"properties\": {\"hw_scsi_model\": \"virtio-scsi\"}}\n instance_ref = objects.Instance(**self.test_instance)\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta,\n [])\n cfg = drvr._get_guest_config(instance_ref, [], image_meta, disk_info)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestController)\n self.assertEqual(cfg.devices[2].model, 'virtio-scsi')\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_virtio_scsi_bus_bdm(self, mock_flavor):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n image_meta = {\"properties\": {\"hw_scsi_model\": \"virtio-scsi\"}}\n instance_ref = objects.Instance(**self.test_instance)\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n conn_info = {'driver_volume_type': 'fake'}\n bd_info = {\n 'block_device_mapping': driver_block_device.convert_volumes([\n fake_block_device.FakeDbBlockDeviceDict(\n {'id': 1,\n 'source_type': 'volume', 'destination_type': 'volume',\n 'device_name': '/dev/sdc', 'disk_bus': 'scsi'}),\n fake_block_device.FakeDbBlockDeviceDict(\n {'id': 2,\n 'source_type': 'volume', 'destination_type': 'volume',\n 'device_name': '/dev/sdd', 'disk_bus': 'scsi'}),\n ])}\n bd_info['block_device_mapping'][0]['connection_info'] = conn_info\n bd_info['block_device_mapping'][1]['connection_info'] = conn_info\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta,\n bd_info)\n with mock.patch.object(\n driver_block_device.DriverVolumeBlockDevice, 'save'\n ) as mock_save:\n cfg = drvr._get_guest_config(instance_ref, [], image_meta,\n disk_info, [], bd_info)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestDisk)\n self.assertEqual(cfg.devices[2].target_dev, 'sdc')\n self.assertEqual(cfg.devices[2].target_bus, 'scsi')\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestDisk)\n self.assertEqual(cfg.devices[3].target_dev, 'sdd')\n self.assertEqual(cfg.devices[3].target_bus, 'scsi')\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestController)\n self.assertEqual(cfg.devices[4].model, 'virtio-scsi')\n mock_save.assert_called_with()\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_vnc(self, mock_flavor):\n self.flags(vnc_enabled=True)\n self.flags(virt_type='kvm',\n use_usb_tablet=False,\n group='libvirt')\n self.flags(enabled=False, group='spice')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertEqual(len(cfg.devices), 7)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[4].type, \"vnc\")\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_vnc_and_tablet(self, mock_flavor):\n self.flags(vnc_enabled=True)\n self.flags(virt_type='kvm',\n use_usb_tablet=True,\n group='libvirt')\n self.flags(enabled=False, group='spice')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertEqual(len(cfg.devices), 8)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[4].type, \"tablet\")\n self.assertEqual(cfg.devices[5].type, \"vnc\")\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_spice_and_tablet(self, mock_flavor):\n self.flags(vnc_enabled=False)\n self.flags(virt_type='kvm',\n use_usb_tablet=True,\n group='libvirt')\n self.flags(enabled=True,\n agent_enabled=False,\n group='spice')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertEqual(len(cfg.devices), 8)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[4].type, \"tablet\")\n self.assertEqual(cfg.devices[5].type, \"spice\")\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_spice_and_agent(self, mock_flavor):\n self.flags(vnc_enabled=False)\n self.flags(virt_type='kvm',\n use_usb_tablet=True,\n group='libvirt')\n self.flags(enabled=True,\n agent_enabled=True,\n group='spice')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertEqual(len(cfg.devices), 8)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestChannel)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[4].target_name, \"com.redhat.spice.0\")\n self.assertEqual(cfg.devices[5].type, \"spice\")\n self.assertEqual(cfg.devices[6].type, \"qxl\")\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n @mock.patch('nova.console.serial.acquire_port')\n def test_get_guest_config_serial_console(self, acquire_port,\n mock_flavor):\n self.flags(enabled=True, group='serial_console')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n acquire_port.return_value = 11111\n\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertEqual(8, len(cfg.devices))\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(\"tcp\", cfg.devices[2].type)\n self.assertEqual(11111, cfg.devices[2].listen_port)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_serial_console_through_flavor(self, mock_flavor):\n self.flags(enabled=True, group='serial_console')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'hw:serial_port_count': 3}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertEqual(10, len(cfg.devices))\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[8],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[9],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(\"tcp\", cfg.devices[2].type)\n self.assertEqual(\"tcp\", cfg.devices[3].type)\n self.assertEqual(\"tcp\", cfg.devices[4].type)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_serial_console_invalid_flavor(self, mock_flavor):\n self.flags(enabled=True, group='serial_console')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'hw:serial_port_count': \"a\"}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n self.assertRaises(\n exception.ImageSerialPortNumberInvalid,\n drvr._get_guest_config, instance_ref, [], {}, disk_info)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_serial_console_image_and_flavor(self,\n mock_flavor):\n self.flags(enabled=True, group='serial_console')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n image_meta = {\"properties\": {\"hw_serial_port_count\": \"3\"}}\n instance_ref = objects.Instance(**self.test_instance)\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'hw:serial_port_count': 4}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref, [], image_meta,\n disk_info)\n self.assertEqual(10, len(cfg.devices), cfg.devices)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[8],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[9],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(\"tcp\", cfg.devices[2].type)\n self.assertEqual(\"tcp\", cfg.devices[3].type)\n self.assertEqual(\"tcp\", cfg.devices[4].type)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_serial_console_invalid_img_meta(self,\n mock_flavor):\n self.flags(enabled=True, group='serial_console')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n image_meta = {\"properties\": {\"hw_serial_port_count\": \"fail\"}}\n self.assertRaises(\n exception.ImageSerialPortNumberInvalid,\n drvr._get_guest_config, instance_ref, [], image_meta, disk_info)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n @mock.patch('nova.console.serial.acquire_port')\n def test_get_guest_config_serial_console_through_port_rng_exhausted(\n self, acquire_port, mock_flavor):\n self.flags(enabled=True, group='serial_console')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n acquire_port.side_effect = exception.SocketPortRangeExhaustedException(\n '127.0.0.1')\n self.assertRaises(\n exception.SocketPortRangeExhaustedException,\n drvr._get_guest_config, instance_ref, [], {}, disk_info)\n\n @mock.patch.object(host.Host, \"get_domain\")\n def test_get_serial_ports_from_instance(self, mock_get_domain):\n i = self._test_get_serial_ports_from_instance(None,\n mock_get_domain)\n self.assertEqual([\n ('127.0.0.1', 100),\n ('127.0.0.1', 101),\n ('127.0.0.2', 100),\n ('127.0.0.2', 101)], list(i))\n\n @mock.patch.object(host.Host, \"get_domain\")\n def test_get_serial_ports_from_instance_bind_only(self, mock_get_domain):\n i = self._test_get_serial_ports_from_instance('bind',\n mock_get_domain)\n self.assertEqual([\n ('127.0.0.1', 101),\n ('127.0.0.2', 100)], list(i))\n\n @mock.patch.object(host.Host, \"get_domain\")\n def test_get_serial_ports_from_instance_connect_only(self,\n mock_get_domain):\n i = self._test_get_serial_ports_from_instance('connect',\n mock_get_domain)\n self.assertEqual([\n ('127.0.0.1', 100),\n ('127.0.0.2', 101)], list(i))\n\n def _test_get_serial_ports_from_instance(self, mode, mock_get_domain):\n xml = \"\"\"\n <domain type='kvm'>\n <devices>\n <serial type=\"tcp\">\n <source host=\"127.0.0.1\" service=\"100\" mode=\"connect\"/>\n </serial>\n <serial type=\"tcp\">\n <source host=\"127.0.0.1\" service=\"101\" mode=\"bind\"/>\n </serial>\n <serial type=\"tcp\">\n <source host=\"127.0.0.2\" service=\"100\" mode=\"bind\"/>\n </serial>\n <serial type=\"tcp\">\n <source host=\"127.0.0.2\" service=\"101\" mode=\"connect\"/>\n </serial>\n </devices>\n </domain>\"\"\"\n\n dom = mock.MagicMock()\n dom.XMLDesc.return_value = xml\n mock_get_domain.return_value = dom\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance = objects.Instance(**self.test_instance)\n return drvr._get_serial_ports_from_instance(\n instance, mode=mode)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_type_xen(self, mock_flavor):\n self.flags(vnc_enabled=True)\n self.flags(virt_type='xen',\n use_usb_tablet=False,\n group='libvirt')\n self.flags(enabled=False,\n group='spice')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertEqual(len(cfg.devices), 6)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestConsole)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[3].type, \"vnc\")\n self.assertEqual(cfg.devices[4].type, \"xen\")\n\n @mock.patch.object(libvirt_driver.libvirt_utils, 'get_arch',\n return_value=arch.S390X)\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_type_kvm_on_s390(self, mock_flavor,\n mock_get_arch):\n self.flags(vnc_enabled=False)\n self.flags(virt_type='kvm',\n use_usb_tablet=False,\n group='libvirt')\n\n self._stub_host_capabilities_cpu_arch(arch.S390X)\n\n instance_ref = self._get_flavor_mocked_test_instance(mock_flavor)\n\n cfg = self._get_guest_config_via_fake_api(instance_ref)\n\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n log_file_device = cfg.devices[2]\n self.assertIsInstance(log_file_device,\n vconfig.LibvirtConfigGuestConsole)\n self.assertEqual(\"sclplm\", log_file_device.target_type)\n self.assertEqual(\"file\", log_file_device.type)\n terminal_device = cfg.devices[3]\n self.assertIsInstance(terminal_device,\n vconfig.LibvirtConfigGuestConsole)\n self.assertEqual(\"sclp\", terminal_device.target_type)\n self.assertEqual(\"pty\", terminal_device.type)\n self.assertEqual(\"s390-ccw-virtio\", cfg.os_mach_type)\n\n def _stub_host_capabilities_cpu_arch(self, cpu_arch):\n def get_host_capabilities_stub(self):\n cpu = vconfig.LibvirtConfigGuestCPU()\n cpu.arch = cpu_arch\n\n caps = vconfig.LibvirtConfigCaps()\n caps.host = vconfig.LibvirtConfigCapsHost()\n caps.host.cpu = cpu\n return caps\n\n self.stubs.Set(host.Host, \"get_capabilities\",\n get_host_capabilities_stub)\n\n def _get_flavor_mocked_test_instance(self, mock_flavor):\n instance = objects.Instance(**self.test_instance)\n flavor = instance.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n return instance\n\n def _get_guest_config_via_fake_api(self, instance):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n image_meta = {}\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance,\n image_meta)\n return drvr._get_guest_config(instance, [], {}, disk_info)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_type_xen_pae_hvm(self, mock_flavor):\n self.flags(vnc_enabled=True)\n self.flags(virt_type='xen',\n use_usb_tablet=False,\n group='libvirt')\n self.flags(enabled=False,\n group='spice')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n instance_ref['vm_mode'] = vm_mode.HVM\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n\n self.assertEqual(cfg.os_type, vm_mode.HVM)\n self.assertEqual(cfg.os_loader, CONF.libvirt.xen_hvmloader_path)\n self.assertEqual(3, len(cfg.features))\n self.assertIsInstance(cfg.features[0],\n vconfig.LibvirtConfigGuestFeaturePAE)\n self.assertIsInstance(cfg.features[1],\n vconfig.LibvirtConfigGuestFeatureACPI)\n self.assertIsInstance(cfg.features[2],\n vconfig.LibvirtConfigGuestFeatureAPIC)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_type_xen_pae_pvm(self, mock_flavor):\n self.flags(vnc_enabled=True)\n self.flags(virt_type='xen',\n use_usb_tablet=False,\n group='libvirt')\n self.flags(enabled=False,\n group='spice')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n\n self.assertEqual(cfg.os_type, vm_mode.XEN)\n self.assertEqual(1, len(cfg.features))\n self.assertIsInstance(cfg.features[0],\n vconfig.LibvirtConfigGuestFeaturePAE)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_vnc_and_spice(self, mock_flavor):\n self.flags(vnc_enabled=True)\n self.flags(virt_type='kvm',\n use_usb_tablet=True,\n group='libvirt')\n self.flags(enabled=True,\n agent_enabled=True,\n group='spice')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n self.assertEqual(len(cfg.devices), 10)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestChannel)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[8],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[9],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[4].type, \"tablet\")\n self.assertEqual(cfg.devices[5].target_name, \"com.redhat.spice.0\")\n self.assertEqual(cfg.devices[6].type, \"vnc\")\n self.assertEqual(cfg.devices[7].type, \"spice\")\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_invalid_watchdog_action(self, mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n image_meta = {\"properties\": {\"hw_watchdog_action\": \"something\"}}\n self.assertRaises(exception.InvalidWatchdogAction,\n drvr._get_guest_config,\n instance_ref,\n [],\n image_meta,\n disk_info)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_watchdog_action_image_meta(self,\n mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n image_meta = {\"properties\": {\"hw_watchdog_action\": \"none\"}}\n cfg = drvr._get_guest_config(instance_ref, [], image_meta, disk_info)\n self.assertEqual(len(cfg.devices), 9)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigGuestWatchdog)\n self.assertIsInstance(cfg.devices[8],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(\"none\", cfg.devices[7].action)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def _test_get_guest_config_with_watchdog_action_flavor(self, mock_flavor,\n hw_watchdog_action=\"hw:watchdog_action\"):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {hw_watchdog_action: 'none'}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n\n self.assertEqual(9, len(cfg.devices))\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigGuestWatchdog)\n self.assertIsInstance(cfg.devices[8],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(\"none\", cfg.devices[7].action)\n\n def test_get_guest_config_with_watchdog_action_through_flavor(self):\n self._test_get_guest_config_with_watchdog_action_flavor()\n\n # TODO(pkholkin): the test accepting old property name 'hw_watchdog_action'\n # should be removed in the next release\n def test_get_guest_config_with_watchdog_action_through_flavor_no_scope(\n self):\n self._test_get_guest_config_with_watchdog_action_flavor(\n hw_watchdog_action=\"hw_watchdog_action\")\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_watchdog_overrides_flavor(self,\n mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'hw_watchdog_action': 'none'}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n image_meta = {\"properties\": {\"hw_watchdog_action\": \"pause\"}}\n\n cfg = drvr._get_guest_config(instance_ref, [],\n image_meta, disk_info)\n\n self.assertEqual(9, len(cfg.devices))\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigGuestWatchdog)\n self.assertIsInstance(cfg.devices[8],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(\"pause\", cfg.devices[7].action)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_unsupported_video_driver_through_image_meta(self,\n mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n image_meta = {\"properties\": {\"hw_video_model\": \"something\"}}\n self.assertRaises(exception.InvalidVideoMode,\n drvr._get_guest_config,\n instance_ref,\n [],\n image_meta,\n disk_info)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_video_driver_image_meta(self,\n mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n image_meta = {\"properties\": {\"hw_video_model\": \"vmvga\"}}\n cfg = drvr._get_guest_config(instance_ref, [], image_meta, disk_info)\n self.assertEqual(len(cfg.devices), 8)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[5].type, \"vnc\")\n self.assertEqual(cfg.devices[6].type, \"vmvga\")\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_qga_through_image_meta(self,\n mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n image_meta = {\"properties\": {\"hw_qemu_guest_agent\": \"yes\"}}\n cfg = drvr._get_guest_config(instance_ref, [], image_meta, disk_info)\n self.assertEqual(len(cfg.devices), 9)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigGuestChannel)\n self.assertIsInstance(cfg.devices[8],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[4].type, \"tablet\")\n self.assertEqual(cfg.devices[5].type, \"vnc\")\n self.assertEqual(cfg.devices[7].type, \"unix\")\n self.assertEqual(cfg.devices[7].target_name, \"org.qemu.guest_agent.0\")\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_video_driver_vram(self, mock_flavor):\n self.flags(vnc_enabled=False)\n self.flags(virt_type='kvm', group='libvirt')\n self.flags(enabled=True,\n agent_enabled=True,\n group='spice')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'hw_video:ram_max_mb': \"100\"}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n image_meta = {\"properties\": {\"hw_video_model\": \"qxl\",\n \"hw_video_ram\": \"64\"}}\n\n cfg = drvr._get_guest_config(instance_ref, [],\n image_meta, disk_info)\n self.assertEqual(len(cfg.devices), 8)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestChannel)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[5].type, \"spice\")\n self.assertEqual(cfg.devices[6].type, \"qxl\")\n self.assertEqual(cfg.devices[6].vram, 64 * units.Mi / units.Ki)\n\n @mock.patch('nova.virt.disk.api.teardown_container')\n @mock.patch('nova.virt.libvirt.driver.LibvirtDriver.get_info')\n @mock.patch('nova.virt.disk.api.setup_container')\n @mock.patch('nova.openstack.common.fileutils.ensure_tree')\n @mock.patch.object(fake_libvirt_utils, 'get_instance_path')\n def test_unmount_fs_if_error_during_lxc_create_domain(self,\n mock_get_inst_path, mock_ensure_tree, mock_setup_container,\n mock_get_info, mock_teardown):\n \"\"\"If we hit an error during a `_create_domain` call to `libvirt+lxc`\n we need to ensure the guest FS is unmounted from the host so that any\n future `lvremove` calls will work.\n \"\"\"\n self.flags(virt_type='lxc', group='libvirt')\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n mock_instance = mock.MagicMock()\n mock_get_inst_path.return_value = '/tmp/'\n mock_image_backend = mock.MagicMock()\n drvr.image_backend = mock_image_backend\n mock_image = mock.MagicMock()\n mock_image.path = '/tmp/test.img'\n drvr.image_backend.image.return_value = mock_image\n mock_setup_container.return_value = '/dev/nbd0'\n mock_get_info.side_effect = exception.InstanceNotFound(\n instance_id='foo')\n drvr._conn.defineXML = mock.Mock()\n drvr._conn.defineXML.side_effect = ValueError('somethingbad')\n with contextlib.nested(\n mock.patch.object(drvr, '_is_booted_from_volume',\n return_value=False),\n mock.patch.object(drvr, 'plug_vifs'),\n mock.patch.object(drvr, 'firewall_driver'),\n mock.patch.object(drvr, 'cleanup')):\n self.assertRaises(ValueError,\n drvr._create_domain_and_network,\n self.context,\n 'xml',\n mock_instance, None, None)\n\n mock_teardown.assert_called_with(container_dir='/tmp/rootfs')\n\n def test_video_driver_flavor_limit_not_set(self):\n self.flags(virt_type='kvm', group='libvirt')\n self.flags(enabled=True,\n agent_enabled=True,\n group='spice')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {\"properties\": {\"hw_video_model\": \"qxl\",\n \"hw_video_ram\": \"64\"}}\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n with contextlib.nested(\n mock.patch.object(objects.Flavor, 'get_by_id'),\n mock.patch.object(objects.Instance, 'save'),\n ) as (mock_flavor, mock_instance):\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n self.assertRaises(exception.RequestedVRamTooHigh,\n drvr._get_guest_config,\n instance_ref,\n [],\n image_meta,\n disk_info)\n\n def test_video_driver_ram_above_flavor_limit(self):\n self.flags(virt_type='kvm', group='libvirt')\n self.flags(enabled=True,\n agent_enabled=True,\n group='spice')\n\n instance_ref = objects.Instance(**self.test_instance)\n instance_type = instance_ref.get_flavor()\n instance_type.extra_specs = {'hw_video:ram_max_mb': \"50\"}\n image_meta = {\"properties\": {\"hw_video_model\": \"qxl\",\n \"hw_video_ram\": \"64\"}}\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n with contextlib.nested(\n mock.patch.object(objects.Flavor, 'get_by_id',\n return_value=instance_type),\n mock.patch.object(objects.Instance, 'save')):\n self.assertRaises(exception.RequestedVRamTooHigh,\n drvr._get_guest_config,\n instance_ref,\n [],\n image_meta,\n disk_info)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_without_qga_through_image_meta(self,\n mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {\"properties\": {\"hw_qemu_guest_agent\": \"no\"}}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n image_meta = {\"properties\": {\"hw_qemu_guest_agent\": \"no\"}}\n cfg = drvr._get_guest_config(instance_ref, [], image_meta, disk_info)\n self.assertEqual(len(cfg.devices), 8)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestInput)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[4].type, \"tablet\")\n self.assertEqual(cfg.devices[5].type, \"vnc\")\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_rng_device(self, mock_flavor):\n self.flags(virt_type='kvm',\n use_usb_tablet=False,\n group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {\"properties\": {\"hw_rng_model\": \"virtio\"}}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'hw_rng:allowed': 'True'}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref, [],\n image_meta, disk_info)\n self.assertEqual(len(cfg.devices), 8)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestRng)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[6].model, 'random')\n self.assertIsNone(cfg.devices[6].backend)\n self.assertIsNone(cfg.devices[6].rate_bytes)\n self.assertIsNone(cfg.devices[6].rate_period)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_rng_not_allowed(self, mock_flavor):\n self.flags(virt_type='kvm',\n use_usb_tablet=False,\n group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {\"properties\": {\"hw_rng_model\": \"virtio\"}}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref, [],\n image_meta, disk_info)\n self.assertEqual(len(cfg.devices), 7)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigMemoryBalloon)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_rng_limits(self, mock_flavor):\n self.flags(virt_type='kvm',\n use_usb_tablet=False,\n group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {\"properties\": {\"hw_rng_model\": \"virtio\"}}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'hw_rng:allowed': 'True',\n 'hw_rng:rate_bytes': '1024',\n 'hw_rng:rate_period': '2'}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref, [],\n image_meta, disk_info)\n self.assertEqual(len(cfg.devices), 8)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestRng)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[6].model, 'random')\n self.assertIsNone(cfg.devices[6].backend)\n self.assertEqual(cfg.devices[6].rate_bytes, 1024)\n self.assertEqual(cfg.devices[6].rate_period, 2)\n\n @mock.patch('nova.virt.libvirt.driver.os.path.exists')\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_rng_backend(self, mock_flavor, mock_path):\n self.flags(virt_type='kvm',\n use_usb_tablet=False,\n rng_dev_path='/dev/hw_rng',\n group='libvirt')\n mock_path.return_value = True\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {\"properties\": {\"hw_rng_model\": \"virtio\"}}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'hw_rng:allowed': 'True'}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref, [],\n image_meta, disk_info)\n self.assertEqual(len(cfg.devices), 8)\n self.assertIsInstance(cfg.devices[0],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[1],\n vconfig.LibvirtConfigGuestDisk)\n self.assertIsInstance(cfg.devices[2],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[3],\n vconfig.LibvirtConfigGuestSerial)\n self.assertIsInstance(cfg.devices[4],\n vconfig.LibvirtConfigGuestGraphics)\n self.assertIsInstance(cfg.devices[5],\n vconfig.LibvirtConfigGuestVideo)\n self.assertIsInstance(cfg.devices[6],\n vconfig.LibvirtConfigGuestRng)\n self.assertIsInstance(cfg.devices[7],\n vconfig.LibvirtConfigMemoryBalloon)\n\n self.assertEqual(cfg.devices[6].model, 'random')\n self.assertEqual(cfg.devices[6].backend, '/dev/hw_rng')\n self.assertIsNone(cfg.devices[6].rate_bytes)\n self.assertIsNone(cfg.devices[6].rate_period)\n\n @mock.patch('nova.virt.libvirt.driver.os.path.exists')\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_rng_dev_not_present(self, mock_flavor,\n mock_path):\n self.flags(virt_type='kvm',\n use_usb_tablet=False,\n rng_dev_path='/dev/hw_rng',\n group='libvirt')\n mock_path.return_value = False\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {\"properties\": {\"hw_rng_model\": \"virtio\"}}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'hw_rng:allowed': 'True'}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n self.assertRaises(exception.RngDeviceNotExist,\n drvr._get_guest_config,\n instance_ref,\n [],\n image_meta, disk_info)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_guest_cpu_shares_with_multi_vcpu(self, mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n flavor.vcpus = 4\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n\n self.assertEqual(4096, cfg.cputune.shares)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_cpu_quota(self, mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'quota:cpu_shares': '10000',\n 'quota:cpu_period': '20000'}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n cfg = drvr._get_guest_config(instance_ref, [], {}, disk_info)\n\n self.assertEqual(10000, cfg.cputune.shares)\n self.assertEqual(20000, cfg.cputune.period)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def test_get_guest_config_with_bogus_cpu_quota(self, mock_flavor):\n self.flags(virt_type='kvm', group='libvirt')\n\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n instance_ref = objects.Instance(**self.test_instance)\n image_meta = {}\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {'quota:cpu_shares': 'fishfood',\n 'quota:cpu_period': '20000'}\n mock_flavor.return_value = flavor\n\n disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,\n instance_ref,\n image_meta)\n\n self.assertRaises(ValueError,\n drvr._get_guest_config,\n instance_ref, [], {}, disk_info)\n\n @mock.patch.object(objects.Flavor, 'get_by_id')\n def _test_get_guest_config_sysinfo_serial(self, expected_serial,\n mock_flavor):\n drvr = libvirt_driver.LibvirtDriver(fake.FakeVirtAPI(), True)\n\n instance_ref = objects.Instance(**self.test_instance)\n flavor = instance_ref.get_flavor()\n flavor.extra_specs = {}\n mock_flavor.return_value = flavor\n\n cfg = drvr._get_guest_config_sysinfo(instance_ref)\n\n self.assertIsInstance(cfg, vconfig.LibvirtConfigGuestSysinfo)\n self.assertEqual(version.vendor_string(),\n cfg.system_manufacturer)\n self.assertEqual(version.product_string(),\n cfg.system_product)\n self.assertEqual(version.version_string_with_package(),\n cfg.system_version)\n self.assertEqual(expected_serial,\n cfg.system_serial)\n self.assertEqual(instance_ref['uuid'],\n cfg.system_uuid)\n\n def test_get_guest_config_sysinfo_serial_none(self):\n self.flags(sysinfo_serial=\"none\", group=\"libvirt\")\n self._test_get_guest_config_sysinfo_serial(None)\n\n @mock.patch.object(libvirt_driver.LibvirtDriver,\n \"_get_host_sysinfo_serial_hardware\")\n def test_get_guest_config_sysinfo_serial_hardware(self, mock_uuid):\n self.flags(sysinfo_serial=\"hardware\", group=\"libvirt\")\n\n theuuid = \"56b40135-a973-4eb3-87bb-a2382a3e6dbc\"\n mock_uuid.return_value = theuuid\n\n self._test_get_guest_config_sysinfo_serial(theuuid)\n\n def test_get_guest_config_sysinfo_serial_os(self):\n self.flags(sysinfo_serial=\"os\", group=\"libvirt\")\n\n real_open = __builtin__.open\n with contextlib.nested(\n mock.patch.object(__builtin__, \"open\"),\n ) as (mock_open, ):\n theuuid = \"56b40135-a973-4eb3-87bb-a2382a3e6dbc\"\n\n def fake_open(filename, *args, **kwargs):\n if filename == \"/etc/machine-id\":\n h = mock.MagicMock()\n h.read.return_value = theuuid\n h.__enter__.return_value = h\n return h\n return real_open(filename, *args, **kwargs)\n\n mock_open.side_effect = fake_open\n\n self._test_get_guest_config_sysinfo_serial(theuuid)\n\n def test_get_guest_config_sysinfo"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227597,"cells":{"text":{"kind":"string","value":"from __future__ import absolute_import\nfrom __future__ import print_function\nfrom typing import Tuple\n\nfrom django.conf import settings\nfrom django.core import validators\nfrom django.contrib.sessions.models import Session\nfrom zerver.lib.cache import flush_user_profile\nfrom zerver.lib.context_managers import lockfile\nfrom zerver.models import Realm, RealmEmoji, Stream, UserProfile, UserActivity, \\\n Subscription, Recipient, Message, UserMessage, valid_stream_name, \\\n DefaultStream, UserPresence, Referral, PushDeviceToken, MAX_SUBJECT_LENGTH, \\\n MAX_MESSAGE_LENGTH, get_client, get_stream, get_recipient, get_huddle, \\\n get_user_profile_by_id, PreregistrationUser, get_display_recipient, \\\n to_dict_cache_key, get_realm, stringify_message_dict, bulk_get_recipients, \\\n email_allowed_for_realm, email_to_username, display_recipient_cache_key, \\\n get_user_profile_by_email, get_stream_cache_key, to_dict_cache_key_id, \\\n UserActivityInterval, get_active_user_dicts_in_realm, get_active_streams, \\\n realm_filters_for_domain, RealmFilter, receives_offline_notifications, \\\n ScheduledJob, realm_filters_for_domain, get_active_bot_dicts_in_realm\n\nfrom zerver.lib.avatar import get_avatar_url, avatar_url\nfrom guardian.shortcuts import assign_perm, remove_perm\n\nfrom django.db import transaction, IntegrityError\nfrom django.db.models import F, Q\nfrom django.core.exceptions import ValidationError\nfrom django.utils.importlib import import_module\nfrom django.core.mail import EmailMessage\nfrom django.utils.timezone import now\n\nfrom confirmation.models import Confirmation\nimport six\nfrom six.moves import filter\nfrom six.moves import map\nfrom six.moves import range\n\nsession_engine = import_module(settings.SESSION_ENGINE)\n\nfrom zerver.lib.create_user import random_api_key\nfrom zerver.lib.initial_password import initial_password\nfrom zerver.lib.timestamp import timestamp_to_datetime, datetime_to_timestamp\nfrom zerver.lib.cache_helpers import cache_save_message\nfrom zerver.lib.queue import queue_json_publish\nfrom django.utils import timezone\nfrom zerver.lib.create_user import create_user\nfrom zerver.lib import bugdown\nfrom zerver.lib.cache import cache_with_key, cache_set, \\\n user_profile_by_email_cache_key, cache_set_many, \\\n cache_delete, cache_delete_many, message_cache_key\nfrom zerver.decorator import JsonableError, statsd_increment\nfrom zerver.lib.event_queue import request_event_queue, get_user_events, send_event\nfrom zerver.lib.utils import log_statsd_event, statsd\nfrom zerver.lib.html_diff import highlight_html_differences\nfrom zerver.lib.alert_words import user_alert_words, add_user_alert_words, \\\n remove_user_alert_words, set_user_alert_words\nfrom zerver.lib.push_notifications import num_push_devices_for_user, \\\n send_apple_push_notification, send_android_push_notification\nfrom zerver.lib.notifications import clear_followup_emails_queue\nfrom zerver.lib.narrow import check_supported_events_narrow_filter\nfrom zerver.lib.session_user import get_session_user\n\nimport DNS\nimport ujson\nimport time\nimport traceback\nimport re\nimport datetime\nimport os\nimport platform\nimport logging\nimport itertools\nfrom collections import defaultdict\n\n# Store an event in the log for re-importing messages\ndef log_event(event):\n if settings.EVENT_LOG_DIR is None:\n return\n\n if \"timestamp\" not in event:\n event[\"timestamp\"] = time.time()\n\n if not os.path.exists(settings.EVENT_LOG_DIR):\n os.mkdir(settings.EVENT_LOG_DIR)\n\n template = os.path.join(settings.EVENT_LOG_DIR,\n '%s.' + platform.node()\n + datetime.datetime.now().strftime('.%Y-%m-%d'))\n\n with lockfile(template % ('lock',)):\n with open(template % ('events',), 'a') as log:\n log.write(ujson.dumps(event) + u'\\n')\n\ndef active_user_ids(realm):\n return [userdict['id'] for userdict in get_active_user_dicts_in_realm(realm)]\n\ndef stream_user_ids(stream):\n subscriptions = Subscription.objects.filter(recipient__type=Recipient.STREAM,\n recipient__type_id=stream.id)\n if stream.invite_only:\n subscriptions = subscriptions.filter(active=True)\n\n return [sub['user_profile_id'] for sub in subscriptions.values('user_profile_id')]\n\ndef bot_owner_userids(user_profile):\n is_private_bot = (\n user_profile.default_sending_stream and user_profile.default_sending_stream.invite_only or\n user_profile.default_events_register_stream and user_profile.default_events_register_stream.invite_only)\n if is_private_bot:\n return (user_profile.bot_owner_id,)\n else:\n return active_user_ids(user_profile.realm)\n\ndef realm_user_count(realm):\n return UserProfile.objects.filter(realm=realm, is_active=True, is_bot=False).count()\n\ndef send_signup_message(sender, signups_stream, user_profile,\n internal=False, realm=None):\n if internal:\n # When this is done using manage.py vs. the web interface\n internal_blurb = \" **INTERNAL SIGNUP** \"\n else:\n internal_blurb = \" \"\n\n user_count = realm_user_count(user_profile.realm)\n # Send notification to realm notifications stream if it exists\n # Don't send notification for the first user in a realm\n if user_profile.realm.notifications_stream is not None and user_count > 1:\n internal_send_message(sender, \"stream\",\n user_profile.realm.notifications_stream.name,\n \"New users\", \"%s just signed up for Zulip. Say hello!\" % \\\n (user_profile.full_name,),\n realm=user_profile.realm)\n\n internal_send_message(sender,\n \"stream\", signups_stream, user_profile.realm.domain,\n \"%s <`%s`> just signed up for Zulip!%s(total: **%i**)\" % (\n user_profile.full_name,\n user_profile.email,\n internal_blurb,\n user_count,\n )\n )\n\ndef notify_new_user(user_profile, internal=False):\n if settings.NEW_USER_BOT is not None:\n send_signup_message(settings.NEW_USER_BOT, \"signups\", user_profile, internal)\n statsd.gauge(\"users.signups.%s\" % (user_profile.realm.domain.replace('.', '_')), 1, delta=True)\n\n# Does the processing for a new user account:\n# * Subscribes to default/invitation streams\n# * Fills in some recent historical messages\n# * Notifies other users in realm and Zulip about the signup\n# * Deactivates PreregistrationUser objects\n# * subscribe the user to newsletter if newsletter_data is specified\ndef process_new_human_user(user_profile, prereg_user=None, newsletter_data=None):\n mit_beta_user = user_profile.realm.domain == \"mit.edu\"\n try:\n streams = prereg_user.streams.all()\n except AttributeError:\n # This will catch both the case where prereg_user is None and where it\n # is a MitUser.\n streams = []\n\n # If the user's invitation didn't explicitly list some streams, we\n # add the default streams\n if len(streams) == 0:\n streams = get_default_subs(user_profile)\n bulk_add_subscriptions(streams, [user_profile])\n\n # Give you the last 100 messages on your public streams, so you have\n # something to look at in your home view once you finish the\n # tutorial.\n one_week_ago = now() - datetime.timedelta(weeks=1)\n recipients = Recipient.objects.filter(type=Recipient.STREAM,\n type_id__in=[stream.id for stream in streams\n if not stream.invite_only])\n messages = Message.objects.filter(recipient_id__in=recipients, pub_date__gt=one_week_ago).order_by(\"-id\")[0:100]\n if len(messages) > 0:\n ums_to_create = [UserMessage(user_profile=user_profile, message=message,\n flags=UserMessage.flags.read)\n for message in messages]\n\n UserMessage.objects.bulk_create(ums_to_create)\n\n # mit_beta_users don't have a referred_by field\n if not mit_beta_user and prereg_user is not None and prereg_user.referred_by is not None \\\n and settings.NOTIFICATION_BOT is not None:\n # This is a cross-realm private message.\n internal_send_message(settings.NOTIFICATION_BOT,\n \"private\", prereg_user.referred_by.email, user_profile.realm.domain,\n \"%s <`%s`> accepted your invitation to join Zulip!\" % (\n user_profile.full_name,\n user_profile.email,\n )\n )\n # Mark any other PreregistrationUsers that are STATUS_ACTIVE as\n # inactive so we can keep track of the PreregistrationUser we\n # actually used for analytics\n if prereg_user is not None:\n PreregistrationUser.objects.filter(email__iexact=user_profile.email).exclude(\n id=prereg_user.id).update(status=0)\n else:\n PreregistrationUser.objects.filter(email__iexact=user_profile.email).update(status=0)\n\n notify_new_user(user_profile)\n\n if newsletter_data is not None:\n # If the user was created automatically via the API, we may\n # not want to register them for the newsletter\n queue_json_publish(\n \"signups\",\n {\n 'EMAIL': user_profile.email,\n 'merge_vars': {\n 'NAME': user_profile.full_name,\n 'REALM': user_profile.realm.domain,\n 'OPTIN_IP': newsletter_data[\"IP\"],\n 'OPTIN_TIME': datetime.datetime.isoformat(datetime.datetime.now()),\n },\n },\n lambda event: None)\n\ndef notify_created_user(user_profile):\n event = dict(type=\"realm_user\", op=\"add\",\n person=dict(email=user_profile.email,\n is_admin=user_profile.is_admin(),\n full_name=user_profile.full_name,\n is_bot=user_profile.is_bot))\n send_event(event, active_user_ids(user_profile.realm))\n\ndef notify_created_bot(user_profile):\n\n def stream_name(stream):\n if not stream:\n return None\n return stream.name\n\n default_sending_stream_name = stream_name(user_profile.default_sending_stream)\n default_events_register_stream_name = stream_name(user_profile.default_events_register_stream)\n\n event = dict(type=\"realm_bot\", op=\"add\",\n bot=dict(email=user_profile.email,\n full_name=user_profile.full_name,\n api_key=user_profile.api_key,\n default_sending_stream=default_sending_stream_name,\n default_events_register_stream=default_events_register_stream_name,\n default_all_public_streams=user_profile.default_all_public_streams,\n avatar_url=avatar_url(user_profile),\n owner=user_profile.bot_owner.email,\n ))\n send_event(event, bot_owner_userids(user_profile))\n\ndef do_create_user(email, password, realm, full_name, short_name,\n active=True, bot=False, bot_owner=None,\n avatar_source=UserProfile.AVATAR_FROM_GRAVATAR,\n default_sending_stream=None, default_events_register_stream=None,\n default_all_public_streams=None, prereg_user=None,\n newsletter_data=None):\n event = {'type': 'user_created',\n 'timestamp': time.time(),\n 'full_name': full_name,\n 'short_name': short_name,\n 'user': email,\n 'domain': realm.domain,\n 'bot': bot}\n if bot:\n event['bot_owner'] = bot_owner.email\n log_event(event)\n\n user_profile = create_user(email=email, password=password, realm=realm,\n full_name=full_name, short_name=short_name,\n active=active, bot=bot, bot_owner=bot_owner,\n avatar_source=avatar_source,\n default_sending_stream=default_sending_stream,\n default_events_register_stream=default_events_register_stream,\n default_all_public_streams=default_all_public_streams)\n\n notify_created_user(user_profile)\n if bot:\n notify_created_bot(user_profile)\n else:\n process_new_human_user(user_profile, prereg_user=prereg_user,\n newsletter_data=newsletter_data)\n return user_profile\n\ndef user_sessions(user_profile):\n return [s for s in Session.objects.all()\n if get_session_user(s) == user_profile.id]\n\ndef delete_session(session):\n return session_engine.SessionStore(session.session_key).delete()\n\ndef delete_user_sessions(user_profile):\n for session in Session.objects.all():\n if get_session_user(session) == user_profile.id:\n delete_session(session)\n\ndef delete_realm_user_sessions(realm):\n realm_user_ids = [user_profile.id for user_profile in\n UserProfile.objects.filter(realm=realm)]\n for session in Session.objects.filter(expire_date__gte=datetime.datetime.now()):\n if get_session_user(session) in realm_user_ids:\n delete_session(session)\n\ndef delete_all_user_sessions():\n for session in Session.objects.all():\n delete_session(session)\n\ndef active_humans_in_realm(realm):\n return UserProfile.objects.filter(realm=realm, is_active=True, is_bot=False)\n\ndef do_set_realm_name(realm, name):\n realm.name = name\n realm.save(update_fields=['name'])\n event = dict(\n type=\"realm\",\n op=\"update\",\n property='name',\n value=name,\n )\n send_event(event, active_user_ids(realm))\n return {}\n\ndef do_set_realm_restricted_to_domain(realm, restricted):\n realm.restricted_to_domain = restricted\n realm.save(update_fields=['restricted_to_domain'])\n event = dict(\n type=\"realm\",\n op=\"update\",\n property='restricted_to_domain',\n value=restricted,\n )\n send_event(event, active_user_ids(realm))\n return {}\n\ndef do_set_realm_invite_required(realm, invite_required):\n realm.invite_required = invite_required\n realm.save(update_fields=['invite_required'])\n event = dict(\n type=\"realm\",\n op=\"update\",\n property='invite_required',\n value=invite_required,\n )\n send_event(event, active_user_ids(realm))\n return {}\n\ndef do_set_realm_invite_by_admins_only(realm, invite_by_admins_only):\n realm.invite_by_admins_only = invite_by_admins_only\n realm.save(update_fields=['invite_by_admins_only'])\n event = dict(\n type=\"realm\",\n op=\"update\",\n property='invite_by_admins_only',\n value=invite_by_admins_only,\n )\n send_event(event, active_user_ids(realm))\n return {}\n\ndef do_deactivate_realm(realm):\n \"\"\"\n Deactivate this realm. Do NOT deactivate the users -- we need to be able to\n tell the difference between users that were intentionally deactivated,\n e.g. by a realm admin, and users who can't currently use Zulip because their\n realm has been deactivated.\n \"\"\"\n if realm.deactivated:\n return\n\n realm.deactivated = True\n realm.save(update_fields=[\"deactivated\"])\n\n for user in active_humans_in_realm(realm):\n # Don't deactivate the users, but do delete their sessions so they get\n # bumped to the login screen, where they'll get a realm deactivation\n # notice when they try to log in.\n delete_user_sessions(user)\n\ndef do_deactivate_user(user_profile, log=True, _cascade=True):\n if not user_profile.is_active:\n return\n\n user_profile.is_active = False;\n user_profile.save(update_fields=[\"is_active\"])\n\n delete_user_sessions(user_profile)\n\n if log:\n log_event({'type': 'user_deactivated',\n 'timestamp': time.time(),\n 'user': user_profile.email,\n 'domain': user_profile.realm.domain})\n\n event = dict(type=\"realm_user\", op=\"remove\",\n person=dict(email=user_profile.email,\n full_name=user_profile.full_name))\n send_event(event, active_user_ids(user_profile.realm))\n\n if user_profile.is_bot:\n event = dict(type=\"realm_bot\", op=\"remove\",\n bot=dict(email=user_profile.email,\n full_name=user_profile.full_name))\n send_event(event, bot_owner_userids(user_profile))\n\n if _cascade:\n bot_profiles = UserProfile.objects.filter(is_bot=True, is_active=True,\n bot_owner=user_profile)\n for profile in bot_profiles:\n do_deactivate_user(profile, _cascade=False)\n\ndef do_deactivate_stream(stream, log=True):\n user_profiles = UserProfile.objects.filter(realm=stream.realm)\n for user_profile in user_profiles:\n do_remove_subscription(user_profile, stream)\n\n was_invite_only = stream.invite_only\n stream.deactivated = True\n stream.invite_only = True\n # Preserve as much as possible the original stream name while giving it a\n # special prefix that both indicates that the stream is deactivated and\n # frees up the original name for reuse.\n old_name = stream.name\n new_name = (\"!DEACTIVATED:\" + old_name)[:Stream.MAX_NAME_LENGTH]\n for i in range(20):\n existing_deactivated_stream = get_stream(new_name, stream.realm)\n if existing_deactivated_stream:\n # This stream has alrady been deactivated, keep prepending !s until\n # we have a unique stream name or you've hit a rename limit.\n new_name = (\"!\" + new_name)[:Stream.MAX_NAME_LENGTH]\n else:\n break\n\n # If you don't have a unique name at this point, this will fail later in the\n # code path.\n\n stream.name = new_name[:Stream.MAX_NAME_LENGTH]\n stream.save()\n\n # Remove the old stream information from remote cache.\n old_cache_key = get_stream_cache_key(old_name, stream.realm)\n cache_delete(old_cache_key)\n\n if not was_invite_only:\n stream_dict = stream.to_dict()\n stream_dict.update(dict(name=old_name, invite_only=was_invite_only))\n event = dict(type=\"stream\", op=\"delete\",\n streams=[stream_dict])\n send_event(event, active_user_ids(stream.realm))\n\n return\n\ndef do_change_user_email(user_profile, new_email):\n old_email = user_profile.email\n user_profile.email = new_email\n user_profile.save(update_fields=[\"email\"])\n\n log_event({'type': 'user_email_changed',\n 'old_email': old_email,\n 'new_email': new_email})\n\ndef compute_irc_user_fullname(email):\n return email.split(\"@\")[0] + \" (IRC)\"\n\ndef compute_jabber_user_fullname(email):\n return email.split(\"@\")[0] + \" (XMPP)\"\n\ndef compute_mit_user_fullname(email):\n try:\n # Input is either e.g. username@mit.edu or user|CROSSREALM.INVALID@mit.edu\n match_user = re.match(r'^([a-zA-Z0-9_.-]+)(\\|.+)?@mit\\.edu$', email.lower())\n if match_user and match_user.group(2) is None:\n answer = DNS.dnslookup(\n \"%s.passwd.ns.athena.mit.edu\" % (match_user.group(1),),\n DNS.Type.TXT)\n hesiod_name = answer[0][0].split(':')[4].split(',')[0].strip()\n if hesiod_name != \"\":\n return hesiod_name\n elif match_user:\n return match_user.group(1).lower() + \"@\" + match_user.group(2).upper()[1:]\n except DNS.Base.ServerError:\n pass\n except:\n print (\"Error getting fullname for %s:\" % (email,))\n traceback.print_exc()\n return email.lower()\n\n@cache_with_key(lambda realm, email, f: user_profile_by_email_cache_key(email),\n timeout=3600*24*7)\ndef create_mirror_user_if_needed(realm, email, email_to_fullname):\n try:\n return get_user_profile_by_email(email)\n except UserProfile.DoesNotExist:\n try:\n # Forge a user for this person\n return create_user(email, initial_password(email), realm,\n email_to_fullname(email), email_to_username(email),\n active=False, is_mirror_dummy=True)\n except IntegrityError:\n return get_user_profile_by_email(email)\n\ndef log_message(message):\n if not message.sending_client.name.startswith(\"test:\"):\n log_event(message.to_log_dict())\n\ndef always_push_notify(user):\n # robinhood.io asked to get push notifications for **all** notifyable\n # messages, regardless of idle status\n return user.realm.domain in ['robinhood.io']\n\n# Helper function. Defaults here are overriden by those set in do_send_messages\ndef do_send_message(message, rendered_content = None, no_log = False, stream = None, local_id = None):\n return do_send_messages([{'message': message,\n 'rendered_content': rendered_content,\n 'no_log': no_log,\n 'stream': stream,\n 'local_id': local_id}])[0]\n\ndef do_send_messages(messages):\n # Filter out messages which didn't pass internal_prep_message properly\n messages = [message for message in messages if message is not None]\n\n # Filter out zephyr mirror anomalies where the message was already sent\n already_sent_ids = []\n new_messages = []\n for message in messages:\n if isinstance(message['message'], int):\n already_sent_ids.append(message['message'])\n else:\n new_messages.append(message)\n messages = new_messages\n\n # For consistency, changes to the default values for these gets should also be applied\n # to the default args in do_send_message\n for message in messages:\n message['rendered_content'] = message.get('rendered_content', None)\n message['no_log'] = message.get('no_log', False)\n message['stream'] = message.get('stream', None)\n message['local_id'] = message.get('local_id', None)\n message['sender_queue_id'] = message.get('sender_queue_id', None)\n\n # Log the message to our message log for populate_db to refill\n for message in messages:\n if not message['no_log']:\n log_message(message['message'])\n\n for message in messages:\n if message['message'].recipient.type == Recipient.PERSONAL:\n message['recipients'] = list(set([get_user_profile_by_id(message['message'].recipient.type_id),\n get_user_profile_by_id(message['message'].sender_id)]))\n # For personals, you send out either 1 or 2 copies of the message, for\n # personals to yourself or to someone else, respectively.\n assert((len(message['recipients']) == 1) or (len(message['recipients']) == 2))\n elif (message['message'].recipient.type == Recipient.STREAM or\n message['message'].recipient.type == Recipient.HUDDLE):\n # We use select_related()/only() here, while the PERSONAL case above uses\n # get_user_profile_by_id() to get UserProfile objects from cache. Streams will\n # typically have more recipients than PMs, so get_user_profile_by_id() would be\n # a bit more expensive here, given that we need to hit the DB anyway and only\n # care about the email from the user profile.\n fields = [\n 'user_profile__id',\n 'user_profile__email',\n 'user_profile__is_active',\n 'user_profile__realm__domain'\n ]\n query = Subscription.objects.select_related(\"user_profile\", \"user_profile__realm\").only(*fields).filter(\n recipient=message['message'].recipient, active=True)\n message['recipients'] = [s.user_profile for s in query]\n else:\n raise ValueError('Bad recipient type')\n\n # Only deliver the message to active user recipients\n message['active_recipients'] = [user_profile for user_profile in message['recipients'] if user_profile.is_active]\n message['message'].maybe_render_content(None)\n message['message'].update_calculated_fields()\n\n # Save the message receipts in the database\n user_message_flags = defaultdict(dict) # type: Dict[int, Dict[int, List[str]]]\n with transaction.atomic():\n Message.objects.bulk_create([message['message'] for message in messages])\n ums = []\n for message in messages:\n ums_to_create = [UserMessage(user_profile=user_profile, message=message['message'])\n for user_profile in message['active_recipients']]\n\n # These properties on the Message are set via\n # Message.render_markdown by code in the bugdown inline patterns\n wildcard = message['message'].mentions_wildcard\n mentioned_ids = message['message'].mentions_user_ids\n ids_with_alert_words = message['message'].user_ids_with_alert_words\n is_me_message = message['message'].is_me_message\n\n for um in ums_to_create:\n if um.user_profile.id == message['message'].sender.id and \\\n message['message'].sent_by_human():\n um.flags |= UserMessage.flags.read\n if wildcard:\n um.flags |= UserMessage.flags.wildcard_mentioned\n if um.user_profile_id in mentioned_ids:\n um.flags |= UserMessage.flags.mentioned\n if um.user_profile_id in ids_with_alert_words:\n um.flags |= UserMessage.flags.has_alert_word\n if is_me_message:\n um.flags |= UserMessage.flags.is_me_message\n user_message_flags[message['message'].id][um.user_profile_id] = um.flags_list()\n ums.extend(ums_to_create)\n UserMessage.objects.bulk_create(ums)\n\n for message in messages:\n cache_save_message(message['message'])\n # Render Markdown etc. here and store (automatically) in\n # remote cache, so that the single-threaded Tornado server\n # doesn't have to.\n user_flags = user_message_flags.get(message['message'].id, {})\n sender = message['message'].sender\n user_presences = get_status_dict(sender)\n presences = {}\n for user_profile in message['active_recipients']:\n if user_profile.email in user_presences:\n presences[user_profile.id] = user_presences[user_profile.email]\n\n event = dict(\n type = 'message',\n message = message['message'].id,\n message_dict_markdown = message['message'].to_dict(apply_markdown=True),\n message_dict_no_markdown = message['message'].to_dict(apply_markdown=False),\n presences = presences)\n users = [{'id': user.id,\n 'flags': user_flags.get(user.id, []),\n 'always_push_notify': always_push_notify(user)}\n for user in message['active_recipients']]\n if message['message'].recipient.type == Recipient.STREAM:\n # Note: This is where authorization for single-stream\n # get_updates happens! We only attach stream data to the\n # notify new_message request if it's a public stream,\n # ensuring that in the tornado server, non-public stream\n # messages are only associated to their subscribed users.\n if message['stream'] is None:\n message['stream'] = Stream.objects.select_related(\"realm\").get(id=message['message'].recipient.type_id)\n if message['stream'].is_public():\n event['realm_id'] = message['stream'].realm.id\n event['stream_name'] = message['stream'].name\n if message['stream'].invite_only:\n event['invite_only'] = True\n if message['local_id'] is not None:\n event['local_id'] = message['local_id']\n if message['sender_queue_id'] is not None:\n event['sender_queue_id'] = message['sender_queue_id']\n send_event(event, users)\n if (settings.ENABLE_FEEDBACK and\n message['message'].recipient.type == Recipient.PERSONAL and\n settings.FEEDBACK_BOT in [up.email for up in message['recipients']]):\n queue_json_publish(\n 'feedback_messages',\n message['message'].to_dict(apply_markdown=False),\n lambda x: None\n )\n\n # Note that this does not preserve the order of message ids\n # returned. In practice, this shouldn't matter, as we only\n # mirror single zephyr messages at a time and don't otherwise\n # intermingle sending zephyr messages with other messages.\n return already_sent_ids + [message['message'].id for message in messages]\n\ndef do_create_stream(realm, stream_name):\n # This is used by a management command now, mostly to facilitate testing. It\n # doesn't simulate every single aspect of creating a subscription; for example,\n # we don't send Zulips to users to tell them they have been subscribed.\n stream = Stream()\n stream.realm = realm\n stream.name = stream_name\n stream.save()\n Recipient.objects.create(type_id=stream.id, type=Recipient.STREAM)\n subscribers = UserProfile.objects.filter(realm=realm, is_active=True, is_bot=False)\n bulk_add_subscriptions([stream], subscribers)\n\ndef create_stream_if_needed(realm, stream_name, invite_only=False):\n (stream, created) = Stream.objects.get_or_create(\n realm=realm, name__iexact=stream_name,\n defaults={'name': stream_name, 'invite_only': invite_only})\n if created:\n Recipient.objects.create(type_id=stream.id, type=Recipient.STREAM)\n if not invite_only:\n event = dict(type=\"stream\", op=\"create\",\n streams=[stream.to_dict()])\n send_event(event, active_user_ids(realm))\n return stream, created\n\ndef recipient_for_emails(emails, not_forged_mirror_message,\n user_profile, sender):\n recipient_profile_ids = set()\n normalized_emails = set()\n realm_domains = set()\n normalized_emails.add(sender.email)\n realm_domains.add(sender.realm.domain)\n\n for email in emails:\n try:\n user_profile = get_user_profile_by_email(email)\n except UserProfile.DoesNotExist:\n raise ValidationError(\"Invalid email '%s'\" % (email,))\n if (not user_profile.is_active and not user_profile.is_mirror_dummy) or \\\n user_profile.realm.deactivated:\n raise ValidationError(\"'%s' is no longer using Zulip.\" % (email,))\n recipient_profile_ids.add(user_profile.id)\n normalized_emails.add(user_profile.email)\n realm_domains.add(user_profile.realm.domain)\n\n if not_forged_mirror_message and user_profile.id not in recipient_profile_ids:\n raise ValidationError(\"User not authorized for this query\")\n\n # Prevent cross realm private messages unless it is between only two realms\n # and one of users is a zuliper\n if len(realm_domains) == 2:\n # I'm assuming that cross-realm PMs with the \"admin realm\" are rare, and therefore can be slower\n admin_realm = get_realm(settings.ADMIN_DOMAIN)\n admin_realm_admin_emails = {u.email for u in admin_realm.get_admin_users()}\n # We allow settings.CROSS_REALM_BOT_EMAILS for the hardcoded emails for the feedback and notification bots\n if not (normalized_emails & admin_realm_admin_emails or normalized_emails & settings.CROSS_REALM_BOT_EMAILS):\n raise ValidationError(\"You can't send private messages outside of your organization.\")\n if len(realm_domains) > 2:\n raise ValidationError(\"You can't send private messages outside of your organization.\")\n\n # If the private message is just between the sender and\n # another person, force it to be a personal internally\n if (len(recipient_profile_ids) == 2\n and sender.id in recipient_profile_ids):\n recipient_profile_ids.remove(sender.id)\n\n if len(recipient_profile_ids) > 1:\n # Make sure the sender is included in huddle messages\n recipient_profile_ids.add(sender.id)\n huddle = get_huddle(list(recipient_profile_ids))\n return get_recipient(Recipient.HUDDLE, huddle.id)\n else:\n return get_recipient(Recipient.PERSONAL, list(recipient_profile_ids)[0])\n\ndef already_sent_mirrored_message_id(message):\n if message.recipient.type == Recipient.HUDDLE:\n # For huddle messages, we use a 10-second window because the\n # timestamps aren't guaranteed to actually match between two\n # copies of the same message.\n time_window = datetime.timedelta(seconds=10)\n else:\n time_window = datetime.timedelta(seconds=0)\n\n messages = Message.objects.filter(\n sender=message.sender,\n recipient=message.recipient,\n content=message.content,\n subject=message.subject,\n sending_client=message.sending_client,\n pub_date__gte=message.pub_date - time_window,\n pub_date__lte=message.pub_date + time_window)\n\n if messages.exists():\n return messages[0].id\n return None\n\ndef extract_recipients(s):\n # We try to accept multiple incoming formats for recipients.\n # See test_extract_recipients() for examples of what we allow.\n try:\n data = ujson.loads(s)\n except ValueError:\n data = s\n\n if isinstance(data, six.string_types):\n data = data.split(',')\n\n if not isinstance(data, list):\n raise ValueError(\"Invalid data type for recipients\")\n\n recipients = data\n\n # Strip recipients, and then remove any duplicates and any that\n # are the empty string after being stripped.\n recipients = [recipient.strip() for recipient in recipients]\n return list(set(recipient for recipient in recipients if recipient))\n\n# check_send_message:\n# Returns the id of the sent message. Has same argspec as check_message.\ndef check_send_message(*args, **kwargs):\n message = check_message(*args, **kwargs)\n return do_send_messages([message])[0]\n\ndef check_stream_name(stream_name):\n if stream_name == \"\":\n raise JsonableError(\"Stream can't be empty\")\n if len(stream_name) > Stream.MAX_NAME_LENGTH:\n raise JsonableError(\"Stream name too long\")\n if not valid_stream_name(stream_name):\n raise JsonableError(\"Invalid stream name\")\n\ndef send_pm_if_empty_stream(sender, stream, stream_name):\n if sender.realm.domain == 'mit.edu' or sender.realm.deactivated:\n return\n\n if sender.is_bot and sender.bot_owner is not None:\n # Don't send these notifications for cross-realm bot messages\n # (e.g. from EMAIL_GATEWAY_BOT) since the owner for\n # EMAIL_GATEWAY_BOT is probably the server administrator, not\n # the owner of the bot who could potentially fix the problem.\n if stream.realm != sender.realm:\n return\n\n if stream:\n num_subscribers = stream.num_subscribers()\n\n if stream is None or num_subscribers == 0:\n # Warn a bot's owner if they are sending a message to a stream\n # that does not exist, or has no subscribers\n # We warn the user once every 5 minutes to avoid a flood of\n # PMs on a misconfigured integration, re-using the\n # UserProfile.last_reminder field, which is not used for bots.\n last_reminder = sender.last_reminder_tzaware()\n waitperiod = datetime.timedelta(minutes=UserProfile.BOT_OWNER_STREAM_ALERT_WAITPERIOD)\n if not last_reminder or timezone.now() - last_reminder > waitperiod:\n if stream is None:\n error_msg = \"that stream does not yet exist. To create it, \"\n elif num_subscribers == 0:\n error_msg = \"there are no subscribers to that stream. To join it, \"\n\n content = (\"Hi there! We thought you'd like to know that your bot **%s** just \"\n \"tried to send a message to stream `%s`, but %s\"\n \"click the gear in the left-side stream list.\" %\n (sender.full_name, stream_name, error_msg))\n message = internal_prep_message(settings.NOTIFICATION_BOT, \"private\",\n sender.bot_owner.email, \"\", content)\n do_send_messages([message])\n\n sender.last_reminder = timezone.now()\n sender.save(update_fields=['last_reminder'])\n\n# check_message:\n# Returns message ready for sending with do_send_message on success or the error message (string) on error.\ndef check_message(sender, client, message_type_name, message_to,\n subject_name, message_content, realm=None, forged=False,\n forged_timestamp=None, forwarder_user_profile=None, local_id=None,\n sender_queue_id=None):\n stream = None\n if not message_to and message_type_name == 'stream' and sender.default_sending_stream:\n # Use the users default stream\n message_to = [sender.default_sending_stream.name]\n elif len(message_to) == 0:\n raise JsonableError(\"Message must have recipients\")\n if len(message_content.strip()) == 0:\n raise JsonableError(\"Message must not be empty\")\n message_content = truncate_body(message_content)\n\n if realm is None:\n realm = sender.realm\n\n if message_type_name == 'stream':\n if len(message_to) > 1:\n raise JsonableError(\"Cannot send to multiple streams\")\n\n stream_name = message_to[0].strip()\n check_stream_name(stream_name)\n\n if subject_name is None:\n raise JsonableError(\"Missing topic\")\n subject = subject_name.strip()\n if subject == \"\":\n raise JsonableError(\"Topic can't be empty\")\n subject = truncate_topic(subject)\n ## FIXME: Commented out temporarily while we figure out what we want\n # if not valid_stream_name(subject):\n # return json_error(\"Invalid subject name\")\n\n stream = get_stream(stream_name, realm)\n\n send_pm_if_empty_stream(sender, stream, stream_name)\n\n if stream is None:\n raise JsonableError(\"Stream does not exist\")\n recipient = get_recipient(Recipient.STREAM, stream.id)\n\n if not stream.invite_only:\n # This is a public stream\n pass\n elif subscribed_to_stream(sender, stream):\n # Or it is private, but your are subscribed\n pass\n elif sender.is_api_super_user() or (forwarder_user_profile is not None and\n forwarder_user_profile.is_api_super_user()):\n # Or this request is being done on behalf of a super user\n pass\n elif sender.is_bot and subscribed_to_stream(sender.bot_owner, stream):\n # Or you're a bot and your owner is subscribed.\n pass\n else:\n # All other cases are an error.\n raise JsonableError(\"Not authorized to send to stream '%s'\" % (stream.name,))\n\n elif message_type_name == 'private':\n mirror_message = client and client.name in [\"zephyr_mirror\", \"irc_mirror\", \"jabber_mirror\", \"JabberMirror\"]\n not_forged_mirror_message = mirror_message and not forged\n try:\n recipient = recipient_for_emails(message_to, not_forged_mirror_message,\n forwarder_user_profile, sender)\n except ValidationError as e:\n assert isinstance(e.messages[0], six.string_types)\n raise JsonableError(e.messages[0])\n else:\n raise JsonableError(\"Invalid message type\")\n\n message = Message()\n message.sender = sender\n message.content = message_content\n message.recipient = recipient\n if message_type_name == 'stream':\n message.subject = subject\n if forged and forged_timestamp is not None:\n # Forged messages come with a timestamp\n message.pub_date = timestamp_to_datetime(forged_timestamp)\n else:\n message.pub_date = timezone.now()\n message.sending_client = client\n\n if not message.maybe_render_content(realm.domain):\n raise JsonableError(\"Unable to render message\")\n\n if client.name == \"zephyr_mirror\":\n id = already_sent_mirrored_message_id(message)\n if id is not None:\n return {'message': id}\n\n return {'message': message, 'stream': stream, 'local_id': local_id, 'sender_queue_id': sender_queue_id}\n\ndef internal_prep_message(sender_email, recipient_type_name, recipients,\n subject, content, realm=None):\n \"\"\"\n Create a message object and checks it, but doesn't send it or save it to the database.\n The internal function that calls this can therefore batch send a bunch of created\n messages together as one database query.\n Call do_send_messages with a list of the return values of this method.\n \"\"\"\n if len(content) > MAX_MESSAGE_LENGTH:\n content = content[0:3900] + \"\\n\\n[message was too long and has been truncated]\"\n\n sender = get_user_profile_by_email(sender_email)\n if realm is None:\n realm = sender.realm\n parsed_recipients = extract_recipients(recipients)\n if recipient_type_name == \"stream\":\n stream, _ = create_stream_if_needed(realm, parsed_recipients[0])\n\n try:\n return check_message(sender, get_client(\"Internal\"), recipient_type_name,\n parsed_recipients, subject, content, realm)\n except JsonableError as e:\n logging.error(\"Error queueing internal message by %s: %s\" % (sender_email, str(e)))\n\n return None\n\ndef internal_send_message(sender_email, recipient_type_name, recipients,\n subject, content, realm=None):\n msg = internal_prep_message(sender_email, recipient_type_name, recipients,\n subject, content, realm)\n\n # internal_prep_message encountered an error\n if msg is None:\n return\n\n do_send_messages([msg])\n\ndef pick_color(user_profile):\n subs = Subscription.objects.filter(user_profile=user_profile,\n active=True,\n recipient__type=Recipient.STREAM)\n return pick_color_helper(user_profile, subs)\n\ndef pick_color_helper(user_profile, subs):\n # These colors are shared with the palette in subs.js.\n stream_assignment_colors = [\n \"#76ce90\", \"#fae589\", \"#a6c7e5\", \"#e79ab5\",\n \"#bfd56f\", \"#f4ae55\", \"#b0a5fd\", \"#addfe5\",\n \"#f5ce6e\", \"#c2726a\", \"#94c849\", \"#bd86e5\",\n \"#ee7e4a\", \"#a6dcbf\", \"#95a5fd\", \"#53a063\",\n \"#9987e1\", \"#e4523d\", \"#c2c2c2\", \"#4f8de4\",\n \"#c6a8ad\", \"#e7cc4d\", \"#c8bebf\", \"#a47462\"]\n used_colors = [sub.color for sub in subs if sub.active]\n available_colors = [x for x in stream_assignment_colors if x not in used_colors]\n\n if available_colors:\n return available_colors[0]\n else:\n return stream_assignment_colors[len(used_colors) % len(stream_assignment_colors)]\n\ndef get_subscription(stream_name, user_profile):\n stream = get_stream(stream_name, user_profile.realm)\n recipient = get_recipient(Recipient.STREAM, stream.id)\n return Subscription.objects.get(user_profile=user_profile,\n recipient=recipient, active=True)\n\ndef validate_user_access_to_subscribers(user_profile, stream):\n \"\"\" Validates whether the user can view the subscribers of a stream. Raises a JsonableError if:\n * The user and the stream are in different realms\n * The realm is MIT and the stream is not invite only.\n * The stream is invite only, requesting_user is passed, and that user\n does not subscribe to the stream.\n \"\"\"\n return validate_user_access_to_subscribers_helper(\n user_profile,\n {\"realm__domain\": stream.realm.domain,\n \"realm_id\": stream.realm_id,\n \"invite_only\": stream.invite_only},\n # We use a lambda here so that we only compute whether the\n # user is subscribed if we have to\n lambda: subscribed_to_stream(user_profile, stream))\n\ndef validate_user_access_to_subscribers_helper(user_profile, stream_dict, check_user_subscribed):\n \"\"\" Helper for validate_user_access_to_subscribers that doesn't require a full stream object\n * check_user_subscribed is a function that when called with no\n arguments, will report whether the user is subscribed to the stream\n \"\"\"\n if user_profile is not None and user_profile.realm_id != stream_dict[\"realm_id\"]:\n raise ValidationError(\"Requesting user not on given realm\")\n\n if stream_dict[\"realm__domain\"] == \"mit.edu\" and not stream_dict[\"invite_only\"]:\n raise JsonableError(\"You cannot get subscribers for public streams in this realm\")\n\n if (user_profile is not None and stream_dict[\"invite_only\"] and\n not check_user_subscribed()):\n raise JsonableError(\"Unable to retrieve subscribers for invite-only stream\")\n\n# sub_dict is a dictionary mapping stream_id => whether the user is subscribed to that stream\ndef bulk_get_subscriber_user_ids(stream_dicts, user_profile, sub_dict):\n target_stream_dicts = []\n for stream_dict in stream_dicts:\n try:\n validate_user_access_to_subscribers_helper(user_profile, stream_dict,\n lambda: sub_dict[stream_dict[\"id\"]])\n except JsonableError:\n continue\n target_stream_dicts.append(stream_dict)\n\n subscriptions = Subscription.objects.select_related(\"recipient\").filter(\n recipient__type=Recipient.STREAM,\n recipient__type_id__in=[stream[\"id\"] for stream in target_stream_dicts],\n user_profile__is_active=True,\n active=True).values(\"user_profile_id\", \"recipient__type_id\")\n\n result = dict((stream[\"id\"], []) for stream in stream_dicts) # type: Dict[int, List[int]]\n for sub in subscriptions:\n result[sub[\"recipient__type_id\"]].append(sub[\"user_profile_id\"])\n\n return result\n\ndef get_subscribers_query(stream, requesting_user):\n \"\"\" Build a query to get the subscribers list for a stream, raising a JsonableError if:\n\n 'stream' can either be a string representing a stream name, or a Stream\n object. If it's a Stream object, 'realm' is optional.\n\n The caller can refine this query with select_related(), values(), etc. depending\n on whether it wants objects or just certain fields\n \"\"\"\n validate_user_access_to_subscribers(requesting_user, stream)\n\n # Note that non-active users may still have \"active\" subscriptions, because we\n # want to be able to easily reactivate them with their old subscriptions. This\n # is why the query here has to look at the UserProfile.is_active flag.\n subscriptions = Subscription.objects.filter(recipient__type=Recipient.STREAM,\n recipient__type_id=stream.id,\n user_profile__is_active=True,\n active=True)\n return subscriptions\n\ndef get_subscribers(stream, requesting_user=None):\n subscriptions = get_subscribers_query(stream, requesting_user).select_related()\n return [subscription.user_profile for subscription in subscriptions]\n\ndef get_subscriber_emails(stream, requesting_user=None):\n subscriptions = get_subscribers_query(stream, requesting_user)\n subscriptions = subscriptions.values('user_profile__email')\n return [subscription['user_profile__email'] for subscription in subscriptions]\n\ndef get_subscriber_ids(stream):\n try:\n subscriptions = get_subscribers_query(stream, None)\n except JsonableError:\n return []\n\n rows = subscriptions.values('user_profile_id')\n ids = [row['user_profile_id'] for row in rows]\n return ids\n\ndef get_other_subscriber_ids(stream, user_profile_id):\n ids = get_subscriber_ids(stream)\n return [id for id in ids if id != user_profile_id]\n\ndef maybe_get_subscriber_emails(stream):\n \"\"\" Alternate version of get_subscriber_emails that takes a Stream object only\n (not a name), and simply returns an empty list if unable to get a real\n subscriber list (because we're on the MIT realm). \"\"\"\n try:\n subscribers = get_subscriber_emails(stream)\n except JsonableError:\n subscribers = []\n return subscribers\n\ndef set_stream_color(user_profile, stream_name, color=None):\n subscription = get_subscription(stream_name, user_profile)\n if not color:\n color = pick_color(user_profile)\n subscription.color = color\n subscription.save(update_fields=[\"color\"])\n return color\n\ndef get_subscribers_to_streams(streams):\n \"\"\" Return a dict where the keys are user profiles, and the values are\n arrays of all the streams within 'streams' to which that user is\n subscribed.\n \"\"\"\n subscribes_to = {} # type: Dict[str, List[Stream]]\n for stream in streams:\n try:\n subscribers = get_subscribers(stream)\n except JsonableError:\n # We can't get a subscriber list for this stream. Probably MIT.\n continue\n\n for subscriber in subscribers:\n if subscriber not in subscribes_to:\n subscribes_to[subscriber] = []\n subscribes_to[subscriber].append(stream)\n\n return subscribes_to\n\ndef notify_subscriptions_added(user_profile, sub_pairs, stream_emails, no_log=False):\n if not no_log:\n log_event({'type': 'subscription_added',\n 'user': user_profile.email,\n 'names': [stream.name for sub, stream in sub_pairs],\n 'domain': user_profile.realm.domain})\n\n # Send a notification to the user who subscribed.\n payload = [dict(name=stream.name,\n stream_id=stream.id,\n in_home_view=subscription.in_home_view,\n invite_only=stream.invite_only,\n color=subscription.color,\n email_address=encode_email_address(stream),\n desktop_notifications=subscription.desktop_notifications,\n audible_notifications=subscription.audible_notifications,\n description=stream.description,\n subscribers=stream_emails(stream))\n for (subscription, stream) in sub_pairs]\n event = dict(type=\"subscription\", op=\"add\",\n subscriptions=payload)\n send_event(event, [user_profile.id])\n\ndef bulk_add_subscriptions(streams, users):\n recipients_map = bulk_get_recipients(Recipient.STREAM, [stream.id for stream in streams])\n recipients = [recipient.id for recipient in recipients_map.values()]\n\n stream_map = {}\n for stream in streams:\n stream_map[recipients_map[stream.id].id] = stream\n\n subs_by_user = defaultdict(list) # type: Dict[int, List[Subscription]]\n all_subs_query = Subscription.objects.select_related(\"user_profile\")\n for sub in all_subs_query.filter(user_profile__in=users,\n recipient__type=Recipient.STREAM):\n subs_by_user[sub.user_profile_id].append(sub)\n\n already_subscribed = []\n subs_to_activate = []\n new_subs = []\n for user_profile in users:\n needs_new_sub = set(recipients)\n for sub in subs_by_user[user_profile.id]:\n if sub.recipient_id in needs_new_sub:\n needs_new_sub.remove(sub.recipient_id)\n if sub.active:\n already_subscribed.append((user_profile, stream_map[sub.recipient_id]))\n else:\n subs_to_activate.append((sub, stream_map[sub.recipient_id]))\n # Mark the sub as active, without saving, so that\n # pick_color will consider this to be an active\n # subscription when picking colors\n sub.active = True\n for recipient_id in needs_new_sub:\n new_subs.append((user_profile, recipient_id, stream_map[recipient_id]))\n\n subs_to_add = []\n for (user_profile, recipient_id, stream) in new_subs:\n color = pick_color_helper(user_profile, subs_by_user[user_profile.id])\n sub_to_add = Subscription(user_profile=user_profile, active=True,\n color=color, recipient_id=recipient_id,\n desktop_notifications=user_profile.enable_stream_desktop_notifications,\n audible_notifications=user_profile.enable_stream_sounds)\n subs_by_user[user_profile.id].append(sub_to_add)\n subs_to_add.append((sub_to_add, stream))\n\n # TODO: XXX: This transaction really needs to be done at the serializeable\n # transaction isolation level.\n with transaction.atomic():\n occupied_streams_before = list(get_occupied_streams(user_profile.realm))\n Subscription.objects.bulk_create([sub for (sub, stream) in subs_to_add])\n Subscription.objects.filter(id__in=[sub.id for (sub, stream_name) in subs_to_activate]).update(active=True)\n occupied_streams_after = list(get_occupied_streams(user_profile.realm))\n\n new_occupied_streams = [stream for stream in\n set(occupied_streams_after) - set(occupied_streams_before)\n if not stream.invite_only]\n if new_occupied_streams:\n event = dict(type=\"stream\", op=\"occupy\",\n streams=[stream.to_dict()\n for stream in new_occupied_streams])\n send_event(event, active_user_ids(user_profile.realm))\n\n # Notify all existing users on streams that users have joined\n\n # First, get all users subscribed to the streams that we care about\n # We fetch all subscription information upfront, as it's used throughout\n # the following code and we want to minize DB queries\n all_subs = Subscription.objects.filter(recipient__type=Recipient.STREAM,\n recipient__type_id__in=[stream.id for stream in streams],\n user_profile__is_active=True,\n active=True).select_related('recipient', 'user_profile')\n\n all_subs_by_stream = defaultdict(list) # type: Dict[int, List[UserProfile]]\n emails_by_stream = defaultdict(list) # type: Dict[int, List[str]]\n for sub in all_subs:\n all_subs_by_stream[sub.recipient.type_id].append(sub.user_profile)\n emails_by_stream[sub.recipient.type_id].append(sub.user_profile.email)\n\n def fetch_stream_subscriber_emails(stream):\n if stream.realm.domain == \"mit.edu\" and not stream.invite_only:\n return []\n return emails_by_stream[stream.id]\n\n sub_tuples_by_user = defaultdict(list) # type: Dict[int, List[Tuple[Subscription, Stream]]]\n new_streams = set()\n for (sub, stream) in subs_to_add + subs_to_activate:\n sub_tuples_by_user[sub.user_profile.id].append((sub, stream))\n new_streams.add((sub.user_profile.id, stream.id))\n\n for user_profile in users:\n if len(sub_tuples_by_user[user_profile.id]) == 0:\n continue\n sub_pairs = sub_tuples_by_user[user_profile.id]\n notify_subscriptions_added(user_profile, sub_pairs, fetch_stream_subscriber_emails)\n\n for stream in streams:\n if stream.realm.domain == \"mit.edu\" and not stream.invite_only:\n continue\n\n new_users = [user for user in users if (user.id, stream.id) in new_streams]\n new_user_ids = [user.id for user in new_users]\n all_subscribed_ids = [user.id for user in all_subs_by_stream[stream.id]]\n other_user_ids = set(all_subscribed_ids) - set(new_user_ids)\n if other_user_ids:\n for user_profile in new_users:\n event = dict(type=\"subscription\", op=\"peer_add\",\n subscriptions=[stream.name],\n user_email=user_profile.email)\n send_event(event, other_user_ids)\n\n return ([(user_profile, stream_name) for (user_profile, recipient_id, stream_name) in new_subs] +\n [(sub.user_profile, stream_name) for (sub, stream_name) in subs_to_activate],\n already_subscribed)\n\n# When changing this, also change bulk_add_subscriptions\ndef do_add_subscription(user_profile, stream, no_log=False):\n recipient = get_recipient(Recipient.STREAM, stream.id)\n color = pick_color(user_profile)\n # TODO: XXX: This transaction really needs to be done at the serializeable\n # transaction isolation level.\n with transaction.atomic():\n vacant_before = stream.num_subscribers() == 0\n (subscription, created) = Subscription.objects.get_or_create(\n user_profile=user_profile, recipient=recipient,\n defaults={'active': True, 'color': color,\n 'notifications': user_profile.default_desktop_notifications})\n did_subscribe = created\n if not subscription.active:\n did_subscribe = True\n subscription.active = True\n subscription.save(update_fields=[\"active\"])\n\n if vacant_before and did_subscribe and not stream.invite_only:\n event = dict(type=\"stream\", op=\"occupy\",\n streams=[stream.to_dict()])\n send_event(event, active_user_ids(user_profile.realm))\n\n if did_subscribe:\n emails_by_stream = {stream.id: maybe_get_subscriber_emails(stream)}\n notify_subscriptions_added(user_profile, [(subscription, stream)], lambda stream: emails_by_stream[stream.id], no_log)\n\n user_ids = get_other_subscriber_ids(stream, user_profile.id)\n event = dict(type=\"subscription\", op=\"peer_add\",\n subscriptions=[stream.name],\n user_email=user_profile.email)\n send_event(event, user_ids)\n\n return did_subscribe\n\ndef notify_subscriptions_removed(user_profile, streams, no_log=False):\n if not no_log:\n log_event({'type': 'subscription_removed',\n 'user': user_profile.email,\n 'names': [stream.name for stream in streams],\n 'domain': user_profile.realm.domain})\n\n payload = [dict(name=stream.name, stream_id=stream.id) for stream in streams]\n event = dict(type=\"subscription\", op=\"remove\",\n subscriptions=payload)\n send_event(event, [user_profile.id])\n\n # As with a subscription add, send a 'peer subscription' notice to other\n # subscribers so they know the user unsubscribed.\n # FIXME: This code was mostly a copy-paste from notify_subscriptions_added.\n # We have since streamlined how we do notifications for adds, and\n # we should do the same for removes.\n notifications_for = get_subscribers_to_streams(streams)\n\n for event_recipient, notifications in six.iteritems(notifications_for):\n # Don't send a peer subscription notice to yourself.\n if event_recipient == user_profile:\n continue\n\n stream_names = [stream.name for stream in notifications]\n event = dict(type=\"subscription\", op=\"peer_remove\",\n subscriptions=stream_names,\n user_email=user_profile.email)\n send_event(event, [event_recipient.id])\n\ndef bulk_remove_subscriptions(users, streams):\n recipients_map = bulk_get_recipients(Recipient.STREAM,\n [stream.id for stream in streams])\n stream_map = {}\n for stream in streams:\n stream_map[recipients_map[stream.id].id] = stream\n\n subs_by_user = dict((user_profile.id, []) for user_profile in users) # type: Dict[int, List[Subscription]]\n for sub in Subscription.objects.select_related(\"user_profile\").filter(user_profile__in=users,\n recipient__in=list(recipients_map.values()),\n active=True):\n subs_by_user[sub.user_profile_id].append(sub)\n\n subs_to_deactivate = []\n not_subscribed = []\n for user_profile in users:\n recipients_to_unsub = set([recipient.id for recipient in recipients_map.values()])\n for sub in subs_by_user[user_profile.id]:\n recipients_to_unsub.remove(sub.recipient_id)\n subs_to_deactivate.append((sub, stream_map[sub.recipient_id]))\n for recipient_id in recipients_to_unsub:\n not_subscribed.append((user_profile, stream_map[recipient_id]))\n\n # TODO: XXX: This transaction really needs to be done at the serializeable\n # transaction isolation level.\n with transaction.atomic():\n occupied_streams_before = list(get_occupied_streams(user_profile.realm))\n Subscription.objects.filter(id__in=[sub.id for (sub, stream_name) in\n subs_to_deactivate]).update(active=False)\n occupied_streams_after = list(get_occupied_streams(user_profile.realm))\n\n new_vacant_streams = [stream for stream in\n set(occupied_streams_before) - set(occupied_streams_after)\n if not stream.invite_only]\n if new_vacant_streams:\n event = dict(type=\"stream\", op=\"vacate\",\n streams=[stream.to_dict()\n for stream in new_vacant_streams])\n send_event(event, active_user_ids(user_profile.realm))\n\n streams_by_user = defaultdict(list) # type: Dict[int, List[Stream]]\n for (sub, stream) in subs_to_deactivate:\n streams_by_user[sub.user_profile_id].append(stream)\n\n for user_profile in users:\n if len(streams_by_user[user_profile.id]) == 0:\n continue\n notify_subscriptions_removed(user_profile, streams_by_user[user_profile.id])\n\n return ([(sub.user_profile, stream) for (sub, stream) in subs_to_deactivate],\n not_subscribed)\n\ndef do_remove_subscription(user_profile, stream, no_log=False):\n recipient = get_recipient(Recipient.STREAM, stream.id)\n maybe_sub = Subscription.objects.filter(user_profile=user_profile,\n recipient=recipient)\n if len(maybe_sub) == 0:\n return False\n subscription = maybe_sub[0]\n did_remove = subscription.active\n subscription.active = False\n with transaction.atomic():\n subscription.save(update_fields=[\"active\"])\n vacant_after = stream.num_subscribers() == 0\n\n if vacant_after and did_remove and not stream.invite_only:\n event = dict(type=\"stream\", op=\"vacate\",\n streams=[stream.to_dict()])\n send_event(event, active_user_ids(user_profile.realm))\n\n if did_remove:\n notify_subscriptions_removed(user_profile, [stream], no_log)\n\n return did_remove\n\ndef log_subscription_property_change(user_email, stream_name, property, value):\n event = {'type': 'subscription_property',\n 'property': property,\n 'user': user_email,\n 'stream_name': stream_name,\n 'value': value}\n log_event(event)\n\ndef do_change_subscription_property(user_profile, sub, stream_name,\n property_name, value):\n setattr(sub, property_name, value)\n sub.save(update_fields=[property_name])\n log_subscription_property_change(user_profile.email, stream_name,\n property_name, value)\n\n event = dict(type=\"subscription\",\n op=\"update\",\n email=user_profile.email,\n property=property_name,\n value=value,\n name=stream_name)\n send_event(event, [user_profile.id])\n\ndef do_activate_user(user_profile, log=True, join_date=timezone.now()):\n user_profile.is_active = True\n user_profile.is_mirror_dummy = False\n user_profile.set_password(initial_password(user_profile.email))\n user_profile.date_joined = join_date\n user_profile.save(update_fields=[\"is_active\", \"date_joined\", \"password\",\n \"is_mirror_dummy\"])\n\n if log:\n domain = user_profile.realm.domain\n log_event({'type': 'user_activated',\n 'user': user_profile.email,\n 'domain': domain})\n\n notify_created_user(user_profile)\n\ndef do_reactivate_user(user_profile):\n # Unlike do_activate_user, this is meant for re-activating existing users,\n # so it doesn't reset their password, etc.\n user_profile.is_active = True\n user_profile.save(update_fields=[\"is_active\"])\n\n domain = user_profile.realm.domain\n log_event({'type': 'user_reactivated',\n 'user': user_profile.email,\n 'domain': domain})\n\n notify_created_user(user_profile)\n\ndef do_change_password(user_profile, password, log=True, commit=True,\n hashed_password=False):\n if hashed_password:\n # This is a hashed password, not the password itself.\n user_profile.set_password(password)\n else:\n user_profile.set_password(password)\n if commit:\n user_profile.save(update_fields=[\"password\"])\n if log:\n log_event({'type': 'user_change_password',\n 'user': user_profile.email,\n 'pwhash': user_profile.password})\n\ndef do_change_full_name(user_profile, full_name, log=True):\n user_profile.full_name = full_name\n user_profile.save(update_fields=[\"full_name\"])\n if log:\n log_event({'type': 'user_change_full_name',\n 'user': user_profile.email,\n 'full_name': full_name})\n\n payload = dict(email=user_profile.email,\n full_name=user_profile.full_name)\n send_event(dict(type='realm_user', op='update', person=payload),\n active_user_ids(user_profile.realm))\n if user_profile.is_bot:\n send_event(dict(type='realm_bot', op='update', bot=payload),\n bot_owner_userids(user_profile))\n\ndef do_regenerate_api_key(user_profile, log=True):\n user_profile.api_key = random_api_key()\n user_profile.save(update_fields=[\"api_key\"])\n\n if log:\n log_event({'type': 'user_change_api_key',\n 'user': user_profile.email})\n\n if user_profile.is_bot:\n send_event(dict(type='realm_bot',\n op='update',\n bot=dict(email=user_profile.email,\n api_key=user_profile.api_key,)),\n bot_owner_userids(user_profile))\n\ndef do_change_avatar_source(user_profile, avatar_source, log=True):\n user_profile.avatar_source = avatar_source\n user_profile.save(update_fields=[\"avatar_source\"])\n\n if log:\n log_event({'type': 'user_change_avatar_source',\n 'user': user_profile.email,\n 'avatar_source': avatar_source})\n\n if user_profile.is_bot:\n send_event(dict(type='realm_bot',\n op='update',\n bot=dict(email=user_profile.email,\n avatar_url=avatar_url(user_profile),)),\n bot_owner_userids(user_profile))\n\ndef _default_stream_permision_check(user_profile, stream):\n # Any user can have a None default stream\n if stream is not None:\n if user_profile.is_bot:\n user = user_profile.bot_owner\n else:\n user = user_profile\n if stream.invite_only and not subscribed_to_stream(user, stream):\n raise JsonableError('Insufficient permission')\n\ndef do_change_default_sending_stream(user_profile, stream, log=True):\n _default_stream_permision_check(user_profile, stream)\n\n user_profile.default_sending_stream = stream\n user_profile.save(update_fields=['default_sending_stream'])\n if log:\n log_event({'type': 'user_change_default_sending_stream',\n 'user': user_profile.email,\n 'stream': str(stream)})\n if user_profile.is_bot:\n if stream:\n stream_name = stream.name\n else:\n stream_name = None\n send_event(dict(type='realm_bot',\n op='update',\n bot=dict(email=user_profile.email,\n default_sending_stream=stream_name,)),\n bot_owner_userids(user_profile))\n\ndef do_change_default_events_register_stream(user_profile, stream, log=True):\n _default_stream_permision_check(user_profile, stream)\n\n user_profile.default_events_register_stream = stream\n user_profile.save(update_fields=['default_events_register_stream'])\n if log:\n log_event({'type': 'user_change_default_events_register_stream',\n 'user': user_profile.email,\n 'stream': str(stream)})\n if user_profile.is_bot:\n if stream:\n stream_name = stream.name\n else:\n stream_name = None\n send_event(dict(type='realm_bot',\n op='update',\n bot=dict(email=user_profile.email,\n default_events_register_stream=stream_name,)),\n bot_owner_userids(user_profile))\n\ndef do_change_default_all_public_streams(user_profile, value, log=True):\n user_profile.default_all_public_streams = value\n user_profile.save(update_fields=['default_all_public_streams'])\n if log:\n log_event({'type': 'user_change_default_all_public_streams',\n 'user': user_profile.email,\n 'value': str(value)})\n if user_profile.is_bot:\n send_event(dict(type='realm_bot',\n op='update',\n bot=dict(email=user_profile.email,\n default_all_public_streams=user_profile.default_all_public_streams,)),\n bot_owner_userids(user_profile))\n\ndef do_change_is_admin(user_profile, is_admin, permission='administer'):\n if is_admin:\n assign_perm(permission, user_profile, user_profile.realm)\n else:\n remove_perm(permission, user_profile, user_profile.realm)\n\n if permission == 'administer':\n event = dict(type=\"realm_user\", op=\"update\",\n person=dict(email=user_profile.email,\n is_admin=is_admin))\n send_event(event, active_user_ids(user_profile.realm))\n\ndef do_make_stream_public(user_profile, realm, stream_name):\n stream_name = stream_name.strip()\n stream = get_stream(stream_name, realm)\n\n if not stream:\n raise JsonableError('Unknown stream \"%s\"' % (stream_name,))\n\n if not subscribed_to_stream(user_profile, stream):\n raise JsonableError('You are not invited to this stream.')\n\n stream.invite_only = False\n stream.save(update_fields=['invite_only'])\n return {}\n\ndef do_make_stream_private(realm, stream_name):\n stream_name = stream_name.strip()\n stream = get_stream(stream_name, realm)\n\n if not stream:\n raise JsonableError('Unknown stream \"%s\"' % (stream_name,))\n\n stream.invite_only = True\n stream.save(update_fields=['invite_only'])\n return {}\n\ndef do_rename_stream(realm, old_name, new_name, log=True):\n old_name = old_name.strip()\n new_name = new_name.strip()\n\n stream = get_stream(old_name, realm)\n\n if not stream:\n raise JsonableError('Unknown stream \"%s\"' % (old_name,))\n\n # Will raise if there's an issue.\n check_stream_name(new_name)\n\n if get_stream(new_name, realm) and old_name.lower() != new_name.lower():\n raise JsonableError('Stream name \"%s\" is already taken' % (new_name,))\n\n old_name = stream.name\n stream.name = new_name\n stream.save(update_fields=[\"name\"])\n\n if log:\n log_event({'type': 'stream_name_change',\n 'domain': realm.domain,\n 'new_name': new_name})\n\n recipient = get_recipient(Recipient.STREAM, stream.id)\n messages = Message.objects.filter(recipient=recipient).only(\"id\")\n\n # Update the display recipient and stream, which are easy single\n # items to set.\n old_cache_key = get_stream_cache_key(old_name, realm)\n new_cache_key = get_stream_cache_key(stream.name, realm)\n if old_cache_key != new_cache_key:\n cache_delete(old_cache_key)\n cache_set(new_cache_key, stream)\n cache_set(display_recipient_cache_key(recipient.id), stream.name)\n\n # Delete cache entries for everything else, which is cheaper and\n # clearer than trying to set them. display_recipient is the out of\n # date field in all cases.\n cache_delete_many(message_cache_key(message.id) for message in messages)\n cache_delete_many(\n to_dict_cache_key_id(message.id, True) for message in messages)\n cache_delete_many(\n to_dict_cache_key_id(message.id, False) for message in messages)\n new_email = encode_email_address(stream)\n\n # We will tell our users to essentially\n # update stream.name = new_name where name = old_name\n # and update stream.email = new_email where name = old_name.\n # We could optimize this by trying to send one message, but the\n # client code really wants one property update at a time, and\n # updating stream names is a pretty infrequent operation.\n # More importantly, we want to key these updates by id, not name,\n # since id is the immutable primary key, and obviously name is not.\n data_updates = [\n ['email_address', new_email],\n ['name', new_name],\n ]\n for property, value in data_updates:\n event = dict(\n op=\"update\",\n type=\"stream\",\n property=property,\n value=value,\n name=old_name\n )\n send_event(event, stream_user_ids(stream))\n\n # Even though the token doesn't change, the web client needs to update the\n # email forwarding address to display the correctly-escaped new name.\n return {\"email_address\": new_email}\n\ndef do_change_stream_description(realm, stream_name, new_description):\n stream = get_stream(stream_name, realm)\n stream.description = new_description\n stream.save(update_fields=['description'])\n\n event = dict(type='stream', op='update',\n property='description', name=stream_name,\n value=new_description)\n send_event(event, stream_user_ids(stream))\n return {}\n\ndef do_create_realm(domain, name, restricted_to_domain=True):\n realm = get_realm(domain)\n created = not realm\n if created:\n realm = Realm(domain=domain, name=name,\n restricted_to_domain=restricted_to_domain)\n realm.save()\n\n # Create stream once Realm object has been saved\n notifications_stream, _ = create_stream_if_needed(realm, Realm.DEFAULT_NOTIFICATION_STREAM_NAME)\n realm.notifications_stream = notifications_stream\n realm.save(update_fields=['notifications_stream'])\n\n # Include a welcome message in this notifications stream\n product_name = \"Zulip\"\n content = \"\"\"Hello, and welcome to %s!\n\nThis is a message on stream `%s` with the topic `welcome`. We'll use this stream for system-generated notifications.\"\"\" % (product_name, notifications_stream.name,)\n msg = internal_prep_message(settings.WELCOME_BOT, 'stream',\n notifications_stream.name, \"welcome\",\n content, realm=realm)\n do_send_messages([msg])\n\n # Log the event\n log_event({\"type\": \"realm_created\",\n \"domain\": domain,\n \"restricted_to_domain\": restricted_to_domain})\n\n if settings.NEW_USER_BOT is not None:\n signup_message = \"Signups enabled\"\n if not restricted_to_domain:\n signup_message += \" (open realm)\"\n internal_send_message(settings.NEW_USER_BOT, \"stream\",\n \"signups\", domain, signup_message)\n return (realm, created)\n\ndef do_change_enable_stream_desktop_notifications(user_profile,\n enable_stream_desktop_notifications,\n log=True):\n user_profile.enable_stream_desktop_notifications = enable_stream_desktop_notifications\n user_profile.save(update_fields=[\"enable_stream_desktop_notifications\"])\n event = {'type': 'update_global_notifications',\n 'user': user_profile.email,\n 'notification_name': 'enable_stream_desktop_notifications',\n 'setting': enable_stream_desktop_notifications}\n if log:\n log_event(event)\n send_event(event, [user_profile.id])\n\ndef do_change_enable_stream_sounds(user_profile, enable_stream_sounds, log=True):\n user_profile.enable_stream_sounds = enable_stream_sounds\n user_profile.save(update_fields=[\"enable_stream_sounds\"])\n event = {'type': 'update_global_notifications',\n 'user': user_profile.email,\n 'notification_name': 'enable_stream_sounds',\n 'setting': enable_stream_sounds}\n if log:\n log_event(event)\n send_event(event, [user_profile.id])\n\ndef do_change_enable_desktop_notifications(user_profile, enable_desktop_notifications, log=True):\n user_profile.enable_desktop_notifications = enable_desktop_notifications\n user_profile.save(update_fields=[\"enable_desktop_notifications\"])\n event = {'type': 'update_global_notifications',\n 'user': user_profile.email,\n 'notification_name': 'enable_desktop_notifications',\n 'setting': enable_desktop_notifications}\n if log:\n log_event(event)\n send_event(event, [user_profile.id])\n\ndef do_change_enable_sounds(user_profile, enable_sounds, log=True):\n user_profile.enable_sounds = enable_sounds\n user_profile.save(update_fields=[\"enable_sounds\"])\n event = {'type': 'update_global_notifications',\n 'user': user_profile.email,\n 'notification_name': 'enable_sounds',\n 'setting': enable_sounds}\n if log:\n log_event(event)\n send_event(event, [user_profile.id])\n\ndef do_change_enable_offline_email_notifications(user_profile, offline_email_notifications, log=True):\n user_profile.enable_offline_email_notifications = offline_email_notifications\n user_profile.save(update_fields=[\"enable_offline_email_notifications\"])\n event = {'type': 'update_global_notifications',\n 'user': user_profile.email,\n 'notification_name': 'enable_offline_email_notifications',\n 'setting': offline_email_notifications}\n if log:\n log_event(event)\n send_event(event, [user_profile.id])\n\ndef do_change_enable_offline_push_notifications(user_profile, offline_push_notifications, log=True):\n user_profile.enable_offline_push_notifications = offline_push_notifications\n user_profile.save(update_fields=[\"enable_offline_push_notifications\"])\n event = {'type': 'update_global_notifications',\n 'user': user_profile.email,\n 'notification_name': 'enable_offline_push_notifications',\n 'setting': offline_push_notifications}\n if log:\n log_event(event)\n send_event(event, [user_profile.id])\n\ndef do_change_enable_digest_emails(user_profile, enable_digest_emails, log=True):\n user_profile.enable_digest_emails = enable_digest_emails\n user_profile.save(update_fields=[\"enable_digest_emails\"])\n\n if not enable_digest_emails:\n # Remove any digest emails that have been enqueued.\n clear_followup_emails_queue(user_profile.email)\n\n event = {'type': 'update_global_notifications',\n 'user': user_profile.email,\n 'notification_name': 'enable_digest_emails',\n 'setting': enable_digest_emails}\n if log:\n log_event(event)\n send_event(event, [user_profile.id])\n\ndef do_change_autoscroll_forever(user_profile, autoscroll_forever, log=True):\n user_profile.autoscroll_forever = autoscroll_forever\n user_profile.save(update_fields=[\"autoscroll_forever\"])\n\n if log:\n log_event({'type': 'autoscroll_forever',\n 'user': user_profile.email,\n 'autoscroll_forever': autoscroll_forever})\n\ndef do_change_enter_sends(user_profile, enter_sends):\n user_profile.enter_sends = enter_sends\n user_profile.save(update_fields=[\"enter_sends\"])\n\ndef do_change_default_desktop_notifications(user_profile, default_desktop_notifications):\n user_profile.default_desktop_notifications = default_desktop_notifications\n user_profile.save(update_fields=[\"default_desktop_notifications\"])\n\ndef do_change_twenty_four_hour_time(user_profile, setting_value, log=True):\n user_profile.twenty_four_hour_time = setting_value\n user_profile.save(update_fields=[\"twenty_four_hour_time\"])\n event = {'type': 'update_display_settings',\n 'user': user_profile.email,\n 'setting_name': 'twenty_four_hour_time',\n 'setting': setting_value}\n if log:\n log_event(event)\n send_event(event, [user_profile.id])\n\ndef do_change_left_side_userlist(user_profile, setting_value, log=True):\n user_profile.left_side_userlist = setting_value\n user_profile.save(update_fields=[\"left_side_userlist\"])\n event = {'type': 'update_display_settings',\n 'user': user_profile.email,\n 'setting_name':'left_side_userlist',\n 'setting': setting_value}\n if log:\n log_event(event)\n send_event(event, [user_profile.id])\n\ndef set_default_streams(realm, stream_names):\n DefaultStream.objects.filter(realm=realm).delete()\n for stream_name in stream_names:\n stream, _ = create_stream_if_needed(realm, stream_name)\n DefaultStream.objects.create(stream=stream, realm=realm)\n\n # Always include the realm's default notifications streams, if it exists\n if realm.notifications_stream is not None:\n DefaultStream.objects.get_or_create(stream=realm.notifications_stream, realm=realm)\n\n log_event({'type': 'default_streams',\n 'domain': realm.domain,\n 'streams': stream_names})\n\ndef do_add_default_stream(realm, stream_name):\n stream, _ = create_stream_if_needed(realm, stream_name)\n if DefaultStream.objects.filter(realm=realm, stream=stream).exists():\n return {}\n DefaultStream.objects.create(realm=realm, stream=stream)\n return {}\n\ndef do_remove_default_stream(realm, stream_name):\n stream = get_stream(stream_name, realm)\n if stream is None:\n raise JsonableError(\"Stream does not exist\")\n DefaultStream.objects.filter(realm=realm, stream=stream).delete()\n return {}\n\ndef get_default_streams_for_realm(realm):\n return [default.stream for default in\n DefaultStream.objects.select_related(\"stream\", \"stream__realm\").filter(realm=realm)]\n\ndef get_default_subs(user_profile):\n # Right now default streams are realm-wide. This wrapper gives us flexibility\n # to some day further customize how we set up default streams for new users.\n return get_default_streams_for_realm(user_profile.realm)\n\ndef do_update_user_activity_interval(user_profile, log_time):\n effective_end = log_time + datetime.timedelta(minutes=15)\n\n # This code isn't perfect, because with various races we might end\n # up creating two overlapping intervals, but that shouldn't happen\n # often, and can be corrected for in post-processing\n try:\n last = UserActivityInterval.objects.filter(user_profile=user_profile).order_by(\"-end\")[0]\n # There are two ways our intervals could overlap:\n # (1) The start of the new interval could be inside the old interval\n # (2) The end of the new interval could be inside the old interval\n # In either case, we just extend the old interval to include the new interval.\n if ((log_time <= last.end and log_time >= last.start) or\n (effective_end <= last.end and effective_end >= last.start)):\n last.end = max(last.end, effective_end)\n last.start = min(last.start, log_time)\n last.save(update_fields=[\"start\", \"end\"])\n return\n except IndexError:\n pass\n\n # Otherwise, the intervals don't overlap, so we should make a new one\n UserActivityInterval.objects.create(user_profile=user_profile, start=log_time,\n end=effective_end)\n\n@statsd_increment('user_activity')\ndef do_update_user_activity(user_profile, client, query, log_time):\n (activity, created) = UserActivity.objects.get_or_create(\n user_profile = user_profile,\n client = client,\n query = query,\n defaults={'last_visit': log_time, 'count': 0})\n\n activity.count += 1\n activity.last_visit = log_time\n activity.save(update_fields=[\"last_visit\", \"count\"])\n\ndef send_presence_changed(user_profile, presence):\n presence_dict = presence.to_dict()\n event = dict(type=\"presence\", email=user_profile.email,\n server_timestamp=time.time(),\n presence={presence_dict['client']: presence.to_dict()})\n send_event(event, active_user_ids(user_profile.realm))\n\ndef consolidate_client(client):\n # The web app reports a client as 'website'\n # The desktop app reports a client as ZulipDesktop\n # due to it setting a custom user agent. We want both\n # to count as web users\n\n # Alias ZulipDesktop to website\n if client.name in ['ZulipDesktop']:\n return get_client('website')\n else:\n return client\n\n@statsd_increment('user_presence')\ndef do_update_user_presence(user_profile, client, log_time, status):\n client = consolidate_client(client)\n (presence, created) = UserPresence.objects.get_or_create(\n user_profile = user_profile,\n client = client,\n defaults = {'timestamp': log_time,\n 'status': status})\n\n stale_status = (log_time - presence.timestamp) > datetime.timedelta(minutes=1, seconds=10)\n was_idle = presence.status == UserPresence.IDLE\n became_online = (status == UserPresence.ACTIVE) and (stale_status or was_idle)\n\n # If an object was created, it has already been saved.\n #\n # We suppress changes from ACTIVE to IDLE before stale_status is reached;\n # this protects us from the user having two clients open: one active, the\n # other idle. Without this check, we would constantly toggle their status\n # between the two states.\n if not created and stale_status or was_idle or status == presence.status:\n # The following block attempts to only update the \"status\"\n # field in the event that it actually changed. This is\n # important to avoid flushing the UserPresence cache when the\n # data it would return to a client hasn't actually changed\n # (see the UserPresence post_save hook for details).\n presence.timestamp = log_time\n update_fields = [\"timestamp\"]\n if presence.status != status:\n presence.status = status\n update_fields.append(\"status\")\n presence.save(update_fields=update_fields)\n\n if not user_profile.realm.domain == \"mit.edu\" and (created or became_online):\n # Push event to all users in the realm so they see the new user\n # appear in the presence list immediately, or the newly online\n # user without delay. Note that we won't send an update here for a\n # timestamp update, because we rely on the browser to ping us every 50\n # seconds for realm-wide status updates, and those updates should have\n # recent timestamps, which means the browser won't think active users\n # have gone idle. If we were more aggressive in this function about\n # sending timestamp updates, we could eliminate the ping responses, but\n # that's not a high priority for now, considering that most of our non-MIT\n # realms are pretty small.\n send_presence_changed(user_profile, presence)\n\ndef update_user_activity_interval(user_profile, log_time):\n event={'user_profile_id': user_profile.id,\n 'time': datetime_to_timestamp(log_time)}\n queue_json_publish(\"user_activity_interval\", event,\n lambda e: do_update_user_activity_interval(user_profile, log_time))\n\ndef update_user_presence(user_profile, client, log_time, status,\n new_user_input):\n event={'user_profile_id': user_profile.id,\n 'status': status,\n 'time': datetime_to_timestamp(log_time),\n 'client': client.name}\n\n queue_json_publish(\"user_presence\", event,\n lambda e: do_update_user_presence(user_profile, client,\n log_time, status))\n\n if new_user_input:\n update_user_activity_interval(user_profile, log_time)\n\ndef do_update_pointer(user_profile, pointer, update_flags=False):\n prev_pointer = user_profile.pointer\n user_profile.pointer = pointer\n user_profile.save(update_fields=[\"pointer\"])\n\n if update_flags:\n # Until we handle the new read counts in the Android app\n # natively, this is a shim that will mark as read any messages\n # up until the pointer move\n UserMessage.objects.filter(user_profile=user_profile,\n message__id__gt=prev_pointer,\n message__id__lte=pointer,\n flags=~UserMessage.flags.read) \\\n .update(flags=F('flags').bitor(UserMessage.flags.read))\n\n event = dict(type='pointer', pointer=pointer)\n send_event(event, [user_profile.id])\n\ndef do_update_message_flags(user_profile, operation, flag, messages, all):\n flagattr = getattr(UserMessage.flags, flag)\n\n if all:\n log_statsd_event('bankruptcy')\n msgs = UserMessage.objects.filter(user_profile=user_profile)\n else:\n msgs = UserMessage.objects.filter(user_profile=user_profile,\n message__id__in=messages)\n # Hack to let you star any message\n if msgs.count() == 0:\n if not len(messages) == 1:\n raise JsonableError(\"Invalid message(s)\")\n if flag != \"starred\":\n raise JsonableError(\"Invalid message(s)\")\n # Check that the user could have read the relevant message\n try:\n message = Message.objects.get(id=messages[0])\n except Message.DoesNotExist:\n raise JsonableError(\"Invalid message(s)\")\n recipient = Recipient.objects.get(id=message.recipient_id)\n if recipient.type != Recipient.STREAM:\n raise JsonableError(\"Invalid message(s)\")\n stream = Stream.objects.select_related(\"realm\").get(id=recipient.type_id)\n if not stream.is_public():\n raise JsonableError(\"Invalid message(s)\")\n\n # OK, this is a message that you legitimately have access\n # to via narrowing to the stream it is on, even though you\n # didn't actually receive it. So we create a historical,\n # read UserMessage message row for you to star.\n UserMessage.objects.create(user_profile=user_profile,\n message=message,\n flags=UserMessage.flags.historical | UserMessage.flags.read)\n\n # The filter() statements below prevent postgres from doing a lot of\n # unnecessary work, which is a big deal for users updating lots of\n # flags (e.g. bankruptcy). This patch arose from seeing slow calls\n # to POST /json/messages/flags in the logs. The filter() statements\n # are kind of magical; they are actually just testing the one bit.\n if operation == 'add':\n msgs = msgs.filter(flags=~flagattr)\n count = msgs.update(flags=F('flags').bitor(flagattr))\n elif operation == 'remove':\n msgs = msgs.filter(flags=flagattr)\n count = msgs.update(flags=F('flags').bitand(~flagattr))\n\n event = {'type': 'update_message_flags',\n 'operation': operation,\n 'flag': flag,\n 'messages': messages,\n 'all': all}\n log_event(event)\n send_event(event, [user_profile.id])\n\n statsd.incr(\"flags.%s.%s\" % (flag, operation), count)\n\ndef subscribed_to_stream(user_profile, stream):\n try:\n if Subscription.objects.get(user_profile=user_profile,\n active=True,\n recipient__type=Recipient.STREAM,\n recipient__type_id=stream.id):\n return True\n return False\n except Subscription.DoesNotExist:\n return False\n\ndef truncate_content(content, max_length, truncation_message):\n if len(content) > max_length:\n content = content[:max_length - len(truncation_message)] + truncation_message\n return content\n\ndef truncate_body(body):\n return truncate_content(body, MAX_MESSAGE_LENGTH, \"...\")\n\ndef truncate_topic(topic):\n return truncate_content(topic, MAX_SUBJECT_LENGTH, \"...\")\n\n\ndef update_user_message_flags(message, ums):\n wildcard = message.mentions_wildcard\n mentioned_ids = message.mentions_user_ids\n ids_with_alert_words = message.user_ids_with_alert_words\n changed_ums = set()\n\n def update_flag(um, should_set, flag):\n if should_set:\n if not (um.flags & flag):\n um.flags |= flag\n changed_ums.add(um)\n else:\n if (um.flags & flag):\n um.flags &= ~flag\n changed_ums.add(um)\n\n for um in ums:\n has_alert_word = um.user_profile_id in ids_with_alert_words\n update_flag(um, has_alert_word, UserMessage.flags.has_alert_word)\n\n mentioned = um.user_profile_id in mentioned_ids\n update_flag(um, mentioned, UserMessage.flags.mentioned)\n\n update_flag(um, wildcard, UserMessage.flags.wildcard_mentioned)\n\n for um in changed_ums:\n um.save(update_fields=['flags'])\n\n\ndef do_update_message(user_profile, message_id, subject, propagate_mode, content):\n try:\n message = Message.objects.select_related().get(id=message_id)\n except Message.DoesNotExist:\n raise JsonableError(\"Unknown message id\")\n\n event = {'type': 'update_message',\n 'sender': user_profile.email,\n 'message_id': message_id}\n edit_history_event = {}\n changed_messages = [message]\n\n # You can only edit a message if:\n # 1. You sent it, OR:\n # 2. This is a topic-only edit for a (no topic) message, OR:\n # 3. This is a topic-only edit and you are an admin.\n if message.sender == user_profile:\n pass\n elif (content is None) and ((message.subject == \"(no topic)\") or\n user_profile.is_admin()):\n pass\n else:\n raise JsonableError(\"You don't have permission to edit this message\")\n\n # Set first_rendered_content to be the oldest version of the\n # rendered content recorded; which is the current version if the\n # content hasn't been edited before. Note that because one could\n # have edited just the subject, not every edit history event\n # contains a prev_rendered_content element.\n first_rendered_content = message.rendered_content\n if message.edit_history is not None:\n edit_history = ujson.loads(message.edit_history)\n for old_edit_history_event in edit_history:\n if 'prev_rendered_content' in old_edit_history_event:\n first_rendered_content = old_edit_history_event['prev_rendered_content']\n\n ums = UserMessage.objects.filter(message=message_id)\n\n if content is not None:\n if len(content.strip()) == 0:\n content = \"(deleted)\"\n content = truncate_body(content)\n rendered_content = message.render_markdown(content)\n\n if not rendered_content:\n raise JsonableError(\"We were unable to render your updated message\")\n\n update_user_message_flags(message, ums)\n\n # We are turning off diff highlighting everywhere until ticket #1532 is addressed.\n if False:\n # Don't highlight message edit diffs on prod\n rendered_content = highlight_html_differences(first_rendered_content, rendered_content)\n\n event['orig_content'] = message.content\n event['orig_rendered_content'] = message.rendered_content\n edit_history_event[\"prev_content\"] = message.content\n edit_history_event[\"prev_rendered_content\"] = message.rendered_content\n edit_history_event[\"prev_rendered_content_version\"] = message.rendered_content_version\n message.content = content\n message.set_rendered_content(rendered_content)\n event[\"content\"] = content\n event[\"rendered_content\"] = rendered_content\n\n if subject is not None:\n orig_subject = message.subject\n subject = subject.strip()\n if subject == \"\":\n raise JsonableError(\"Topic can't be empty\")\n subject = truncate_topic(subject)\n event[\"orig_subject\"] = orig_subject\n event[\"propagate_mode\"] = propagate_mode\n message.subject = subject\n event[\"stream_id\"] = message.recipient.type_id\n event[\"subject\"] = subject\n event['subject_links'] = bugdown.subject_links(message.sender.realm.domain.lower(), subject)\n edit_history_event[\"prev_subject\"] = orig_subject\n\n\n if propagate_mode in [\"change_later\", \"change_all\"]:\n propagate_query = Q(recipient = message.recipient, subject = orig_subject)\n # We only change messages up to 2 days in the past, to avoid hammering our\n # DB by changing an unbounded amount of messages\n if propagate_mode == 'change_all':\n before_bound = now() - datetime.timedelta(days=2)\n\n propagate_query = propagate_query & ~Q(id = message.id) & \\\n Q(pub_date__range=(before_bound, now()))\n if propagate_mode == 'change_later':\n propagate_query = propagate_query & Q(id__gt = message.id)\n\n messages = Message.objects.filter(propagate_query).select_related();\n\n # Evaluate the query before running the update\n messages_list = list(messages)\n messages.update(subject=subject)\n\n for m in messages_list:\n # The cached ORM object is not changed by messages.update()\n # and the remote cache update requires the new value\n m.subject = subject\n\n changed_messages += messages_list\n\n message.last_edit_time = timezone.now()\n event['edit_timestamp'] = datetime_to_timestamp(message.last_edit_time)\n edit_history_event['timestamp'] = event['edit_timestamp']\n if message.edit_history is not None:\n edit_history.insert(0, edit_history_event)\n else:\n edit_history = [edit_history_event]\n message.edit_history = ujson.dumps(edit_history)\n\n log_event(event)\n message.save(update_fields=[\"subject\", \"content\", \"rendered_content\",\n \"rendered_content_version\", \"last_edit_time\",\n \"edit_history\"])\n\n # Update the message as stored in the (deprecated) message\n # cache (for shunting the message over to Tornado in the old\n # get_messages API) and also the to_dict caches.\n items_for_remote_cache = {}\n event['message_ids'] = []\n for changed_message in changed_messages:\n event['message_ids'].append(changed_message.id)\n items_for_remote_cache[message_cache_key(changed_message.id)] = (changed_message,)\n items_for_remote_cache[to_dict_cache_key(changed_message, True)] = \\\n (stringify_message_dict(changed_message.to_dict_uncached(apply_markdown=True)),)\n items_for_remote_cache[to_dict_cache_key(changed_message, False)] = \\\n (stringify_message_dict(changed_message.to_dict_uncached(apply_markdown=False)),)\n cache_set_many(items_for_remote_cache)\n\n def user_info(um):\n return {\n 'id': um.user_profile_id,\n 'flags': um.flags_list()\n }\n send_event(event, list(map(user_info, ums)))\n\ndef encode_email_address(stream):\n return encode_email_address_helper(stream.name, stream.email_token)\n\ndef encode_email_address_helper(name, email_token):\n # Some deployments may not use the email gateway\n if settings.EMAIL_GATEWAY_PATTERN == '':\n return ''\n\n # Given the fact that we have almost no restrictions on stream names and\n # that what characters are allowed in e-mail addresses is complicated and\n # dependent on context in the address, we opt for a very simple scheme:\n #\n # Only encode the stream name (leave the + and token alone). Encode\n # everything that isn't alphanumeric plus _ as the percent-prefixed integer\n # ordinal of that character, padded with zeroes to the maximum number of\n # bytes of a UTF-8 encoded Unicode character.\n encoded_name = re.sub(\"\\W\", lambda x: \"%\" + str(ord(x.group(0))).zfill(4), name)\n encoded_token = \"%s+%s\" % (encoded_name, email_token)\n return settings.EMAIL_GATEWAY_PATTERN % (encoded_token,)\n\ndef get_email_gateway_message_string_from_address(address):\n pattern_parts = [re.escape(part) for part in settings.EMAIL_GATEWAY_PATTERN.split('%s')]\n if settings.ZULIP_COM:\n # Accept mails delivered to any Zulip server\n pattern_parts[-1] = r'@[\\w-]*\\.zulip\\.net'\n match_email_re = re.compile(\"(.*?)\".join(pattern_parts))\n match = match_email_re.match(address)\n\n if not match:\n return None\n\n msg_string = match.group(1)\n\n return msg_string\n\ndef decode_email_address(email):\n # Perform the reverse of encode_email_address. Returns a tuple of (streamname, email_token)\n msg_string = get_email_gateway_message_string_from_address(email)\n\n if '.' in msg_string:\n # Workaround for Google Groups and other programs that don't accept emails\n # that have + signs in them (see Trac #2102)\n encoded_stream_name, token = msg_string.split('.')\n else:\n encoded_stream_name, token = msg_string.split('+')\n stream_name = re.sub(\"%\\d{4}\", lambda x: unichr(int(x.group(0)[1:])), encoded_stream_name)\n return stream_name, token\n\n# In general, it's better to avoid using .values() because it makes\n# the code pretty ugly, but in this case, it has significant\n# performance impact for loading / for users with large numbers of\n# subscriptions, so it's worth optimizing.\ndef gather_subscriptions_helper(user_profile):\n sub_dicts = Subscription.objects.select_related(\"recipient\").filter(\n user_profile = user_profile,\n recipient__type = Recipient.STREAM).values(\n \"recipient__type_id\", \"in_home_view\", \"color\", \"desktop_notifications\",\n \"audible_notifications\", \"active\")\n\n stream_ids = [sub[\"recipient__type_id\"] for sub in sub_dicts]\n\n stream_dicts = get_active_streams(user_profile.realm).select_related(\n \"realm\").filter(id__in=stream_ids).values(\n \"id\", \"name\", \"invite_only\", \"realm_id\", \"realm__domain\", \"email_token\", \"description\")\n stream_hash = {}\n for stream in stream_dicts:\n stream_hash[stream[\"id\"]] = stream\n\n subscribed = []\n unsubscribed = []\n\n # Deactivated streams aren't in stream_hash.\n streams = [stream_hash[sub[\"recipient__type_id\"]] for sub in sub_dicts \\\n if sub[\"recipient__type_id\"] in stream_hash]\n streams_subscribed_map = dict((sub[\"recipient__type_id\"], sub[\"active\"]) for sub in sub_dicts)\n subscriber_map = bulk_get_subscriber_user_ids(streams, user_profile, streams_subscribed_map)\n\n for sub in sub_dicts:\n stream = stream_hash.get(sub[\"recipient__type_id\"])\n if not stream:\n # This stream has been deactivated, don't include it.\n continue\n\n subscribers = subscriber_map[stream[\"id\"]]\n\n # Important: don't show the subscribers if the stream is invite only\n # and this user isn't on it anymore.\n if stream[\"invite_only\"] and not sub[\"active\"]:\n subscribers = None\n\n stream_dict = {'name': stream[\"name\"],\n 'in_home_view': sub[\"in_home_view\"],\n 'invite_only': stream[\"invite_only\"],\n 'color': sub[\"color\"],\n 'desktop_notifications': sub[\"desktop_notifications\"],\n 'audible_notifications': sub[\"audible_notifications\"],\n 'stream_id': stream[\"id\"],\n 'description': stream[\"description\"],\n 'email_address': encode_email_address_helper(stream[\"name\"], stream[\"email_token\"])}\n if subscribers is not None:\n stream_dict['subscribers'] = subscribers\n if sub[\"active\"]:\n subscribed.append(stream_dict)\n else:\n unsubscribed.append(stream_dict)\n\n user_ids = set()\n for subs in [subscribed, unsubscribed]:\n for sub in subs:\n if 'subscribers' in sub:\n for subscriber in sub['subscribers']:\n user_ids.add(subscriber)\n email_dict = get_emails_from_user_ids(list(user_ids))\n return (sorted(subscribed, key=lambda x: x['name']),\n sorted(unsubscribed, key=lambda x: x['name']),\n email_dict)\n\ndef gather_subscriptions(user_profile):\n subscribed, unsubscribed, email_dict = gather_subscriptions_helper(user_profile)\n for subs in [subscribed, unsubscribed]:\n for sub in subs:\n if 'subscribers' in sub:\n sub['subscribers'] = [email_dict[user_id] for user_id in sub['subscribers']]\n\n return (subscribed, unsubscribed)\n\ndef get_status_dict(requesting_user_profile):\n # Return no status info for MIT\n if requesting_user_profile.realm.domain == 'mit.edu':\n return defaultdict(dict)\n\n return UserPresence.get_status_dict_by_realm(requesting_user_profile.realm_id)\n\n\ndef get_realm_user_dicts(user_profile):\n # Due to our permission model, it is advantageous to find the admin users in bulk.\n admins = user_profile.realm.get_admin_users()\n admin_emails = set([up.email for up in admins])\n return [{'email' : userdict['email'],\n 'is_admin' : userdict['email'] in admin_emails,\n 'is_bot' : userdict['is_bot'],\n 'full_name' : userdict['full_name']}\n for userdict in get_active_user_dicts_in_realm(user_profile.realm)]\n\ndef get_realm_bot_dicts(user_profile):\n return [{'email': botdict['email'],\n 'full_name': botdict['full_name'],\n 'api_key': botdict['api_key'],\n 'default_sending_stream': botdict['default_sending_stream__name'],\n 'default_events_register_stream': botdict['default_events_register_stream__name'],\n 'default_all_public_streams': botdict['default_all_public_streams'],\n 'owner': botdict['bot_owner__email'],\n 'avatar_url': get_avatar_url(botdict['avatar_source'], botdict['email']),\n }\n for botdict in get_active_bot_dicts_in_realm(user_profile.realm)]\n\n# Fetch initial data. When event_types is not specified, clients want\n# all event types. Whenever you add new code to this function, you\n# should also add corresponding events for changes in the data\n# structures and new code to apply_events (and add a test in EventsRegisterTest).\ndef fetch_initial_state_data(user_profile, event_types, queue_id):\n state = {'queue_id': queue_id}\n\n if event_types is None:\n want = lambda msg_type: True\n else:\n want = set(event_types).__contains__\n\n if want('alert_words'):\n state['alert_words'] = user_alert_words(user_profile)\n\n if want('message'):\n # The client should use get_old_messages() to fetch messages\n # starting with the max_message_id. They will get messages\n # newer than that ID via get_events()\n messages = Message.objects.filter(usermessage__user_profile=user_profile).order_by('-id')[:1]\n if messages:\n state['max_message_id'] = messages[0].id\n else:\n state['max_message_id'] = -1\n\n if want('muted_topics'):\n state['muted_topics'] = ujson.loads(user_profile.muted_topics)\n\n if want('pointer'):\n state['pointer'] = user_profile.pointer\n\n if want('presence'):\n state['presences'] = get_status_dict(user_profile)\n\n if want('realm'):\n state['realm_name'] = user_profile.realm.name\n state['realm_restricted_to_domain'] = user_profile.realm.restricted_to_domain\n state['realm_invite_required'] = user_profile.realm.invite_required\n state['realm_invite_by_admins_only'] = user_profile.realm.invite_by_admins_only\n\n if want('realm_domain'):\n state['realm_domain'] = user_profile.realm.domain\n\n if want('realm_emoji'):\n state['realm_emoji'] = user_profile.realm.get_emoji()\n\n if want('realm_filters'):\n state['realm_filters'] = realm_filters_for_domain(user_profile.realm.domain)\n\n if want('realm_user'):\n state['realm_users'] = get_realm_user_dicts(user_profile)\n\n if want('realm_bot'):\n state['realm_bots'] = get_realm_bot_dicts(user_profile)\n\n if want('referral'):\n state['referrals'] = {'granted': user_profile.invites_granted,\n 'used': user_profile.invites_used}\n\n if want('subscription'):\n subscriptions, unsubscribed, email_dict = gather_subscriptions_helper(user_profile)\n state['subscriptions'] = subscriptions\n state['unsubscribed'] = unsubscribed\n state['email_dict'] = email_dict\n\n if want('update_message_flags'):\n # There's no initial data for message flag updates, client will\n # get any updates during a session from get_events()\n pass\n\n if want('stream'):\n state['streams'] = do_get_streams(user_profile)\n\n if want('update_display_settings'):\n state['twenty_four_hour_time'] = user_profile.twenty_four_hour_time\n state['left_side_userlist'] = user_profile.left_side_userlist\n\n return state\n\ndef apply_events(state, events, user_profile):\n for event in events:\n if event['type'] == \"message\":\n state['max_message_id'] = max(state['max_message_id'], event['message']['id'])\n elif event['type'] == \"pointer\":\n state['pointer'] = max(state['pointer'], event['pointer'])\n elif event['type'] == \"realm_user\":\n person = event['person']\n\n def our_person(p):\n return p['email'] == person['email']\n\n if event['op'] == \"add\":\n state['realm_users'].append(person)\n elif event['op'] == \"remove\":\n state['realm_users'] = [x for x in state['realm_users'] if not our_person(x)]\n elif event['op'] == 'update':\n for p in state['realm_users']:\n if our_person(p):\n p.update(person)\n\n elif event['type'] == 'realm_bot':\n if event['op'] == 'add':\n state['realm_bots'].append(event['bot'])\n\n if event['op'] == 'remove':\n email = event['bot']['email']\n state['realm_bots'] = [b for b in state['realm_bots'] if b['email'] != email]\n\n if event['op'] == 'update':\n for bot in state['realm_bots']:\n if bot['email'] == event['bot']['email']:\n bot.update(event['bot'])\n\n elif event['type'] == 'stream':\n if event['op'] == 'update':\n # For legacy reasons, we call stream data 'subscriptions' in\n # the state var here, for the benefit of the JS code.\n for obj in state['subscriptions']:\n if obj['name'].lower() == event['name'].lower():\n obj[event['property']] = event['value']\n # Also update the pure streams data\n for stream in state['streams']:\n if stream['name'].lower() == event['name'].lower():\n prop = event['property']\n if prop in stream:\n stream[prop] = event['value']\n elif event['op'] == \"occupy\":\n state['streams'] += event['streams']\n elif event['op'] == \"vacate\":\n stream_ids = [s[\"stream_id\"] for s in event['streams']]\n state['streams'] = [s for s in state['streams'] if s[\"stream_id\"] not in stream_ids]\n elif event['type'] == 'realm':\n field = 'realm_' + event['property']\n state[field] = event['value']\n elif event['type'] == \"subscription\":\n if event['op'] in [\"add\"]:\n # Convert the user_profile IDs to emails since that's what register() returns\n # TODO: Clean up this situation\n for item in event[\"subscriptions\"]:\n item[\"subscribers\"] = [get_user_profile_by_email(email).id for email in item[\"subscribers\"]]\n\n def name(sub):\n return sub['name'].lower()\n\n if event['op'] == \"add\":\n added_names = set(map(name, event[\"subscriptions\"]))\n was_added = lambda s: name(s) in added_names\n\n # add the new subscriptions\n state['subscriptions'] += event['subscriptions']\n\n # remove them from unsubscribed if they had been there\n state['unsubscribed'] = [x for x in state['unsubscribed'] if not was_added(x)]\n\n elif event['op'] == \"remove\":\n removed_names = set(map(name, event[\"subscriptions\"]))\n was_removed = lambda s: name(s) in removed_names\n\n # Find the subs we are affecting.\n removed_subs = list(filter(was_removed, state['subscriptions']))\n\n # Remove our user from the subscribers of the removed subscriptions.\n for sub in removed_subs:\n sub['subscribers'] = [id for id in sub['subscribers'] if id != user_profile.id]\n\n # We must effectively copy the removed subscriptions from subscriptions to\n # unsubscribe, since we only have the name in our data structure.\n state['unsubscribed'] += removed_subs\n\n # Now filter out the removed subscriptions from subscriptions.\n state['subscriptions'] = [x for x in state['subscriptions'] if not was_removed(x)]\n\n elif event['op'] == 'update':\n for sub in state['subscriptions']:\n if sub['name'].lower() == event['name'].lower():\n sub[event['property']] = event['value']\n elif event['op'] == 'peer_add':\n user_id = get_user_profile_by_email(event['user_email']).id\n for sub in state['subscriptions']:\n if (sub['name'] in event['subscriptions'] and\n user_id not in sub['subscribers']):\n sub['subscribers'].append(user_id)\n elif event['op'] == 'peer_remove':\n user_id = get_user_profile_by_email(event['user_email']).id\n for sub in state['subscriptions']:\n if (sub['name'] in event['subscriptions'] and\n user_id in sub['subscribers']):\n sub['subscribers'].remove(user_id)\n elif event['type'] == \"presence\":\n state['presences'][event['email']] = event['presence']\n elif event['type'] == \"update_message\":\n # The client will get the updated message directly\n pass\n elif event['type'] == \"referral\":\n state['referrals'] = event['referrals']\n elif event['type'] == \"update_message_flags\":\n # The client will get the message with the updated flags directly\n pass\n elif event['type'] == \"realm_emoji\":\n state['realm_emoji'] = event['realm_emoji']\n elif event['type'] == \"alert_words\":\n state['alert_words'] = event['alert_words']\n elif event['type'] == \"muted_topics\":\n state['muted_topics'] = event[\"muted_topics\"]\n elif event['type'] == \"realm_filters\":\n state['realm_filters'] = event[\"realm_filters\"]\n elif event['type'] == \"update_display_settings\":\n if event['setting_name'] == \"twenty_four_hour_time\":\n state['twenty_four_hour_time'] = event[\"setting\"]\n if event['setting_name'] == 'left_side_userlist':\n state['left_side_userlist'] = event[\"setting\"]\n else:\n raise ValueError(\"Unexpected event type %s\" % (event['type'],))\n\ndef do_events_register(user_profile, user_client, apply_markdown=True,\n event_types=None, queue_lifespan_secs=0, all_public_streams=False,\n narrow=[]):\n # Technically we don't need to check this here because\n # build_narrow_filter will check it, but it's nicer from an error\n # handling perspective to do it before contacting Tornado\n check_supported_events_narrow_filter(narrow)\n queue_id = request_event_queue(user_profile, user_client, apply_markdown,\n queue_lifespan_secs, event_types, all_public_streams,\n narrow=narrow)\n if queue_id is None:\n raise JsonableError(\"Could not allocate event queue\")\n if event_types is not None:\n event_types = set(event_types)\n\n ret = fetch_initial_state_data(user_profile, event_types, queue_id)\n\n # Apply events that came in while we were fetching initial data\n events = get_user_events(user_profile, queue_id, -1)\n apply_events(ret, events, user_profile)\n if events:\n ret['last_event_id'] = events[-1]['id']\n else:\n ret['last_event_id'] = -1\n return ret\n\ndef do_send_confirmation_email(invitee, referrer):\n \"\"\"\n Send the confirmation/welcome e-mail to an invited user.\n\n `invitee` is a PreregistrationUser.\n `referrer` is a UserProfile.\n \"\"\"\n subject_template_path = 'confirmation/invite_email_subject.txt'\n body_template_path = 'confirmation/invite_email_body.txt'\n context = {'referrer': referrer,\n 'support_email': settings.ZULIP_ADMINISTRATOR,\n 'voyager': settings.VOYAGER}\n\n if referrer.realm.domain == 'mit.edu':\n subject_template_path = 'confirmation/mituser_invite_email_subject.txt'\n body_template_path = 'confirmation/mituser_invite_email_body.txt'\n\n Confirmation.objects.send_confirmation(\n invitee, invitee.email, additional_context=context,\n subject_template_path=subject_template_path,\n body_template_path=body_template_path)\n\n@statsd_increment(\"push_notifications\")\ndef handle_push_notification(user_profile_id, missed_message):\n try:\n user_profile = get_user_profile_by_id(user_profile_id)\n if not receives_offline_notifications(user_profile):\n return\n\n umessage = UserMessage.objects.get(user_profile=user_profile,\n message__id=missed_message['message_id'])\n message = umessage.message\n if umessage.flags.read:\n return\n sender_str = message.sender.full_name\n\n apple = num_push_devices_for_user(user_profile, kind=PushDeviceToken.APNS)\n android = num_push_devices_for_user(user_profile, kind=PushDeviceToken.GCM)\n\n if apple or android:\n #TODO: set badge count in a better way\n # Determine what alert string to display based on the missed messages\n if message.recipient.type == Recipient.HUDDLE:\n alert = \"New private group message from %s\" % (sender_str,)\n elif message.recipient.type == Recipient.PERSONAL:\n alert = \"New private message from %s\" % (sender_str,)\n elif message.recipient.type == Recipient.STREAM:\n alert = \"New mention from %s\" % (sender_str,)\n else:\n alert = \"New Zulip mentions and private messages from %s\" % (sender_str,)\n\n if apple:\n apple_extra_data = {'message_ids': [message.id]}\n send_apple_push_notification(user_profile, alert, badge=1, zulip=apple_extra_data)\n\n if android:\n content = message.content\n content_truncated = (len(content) > 200)\n if content_truncated:\n content = content[:200] + \"...\"\n\n android_data = {\n 'user': user_profile.email,\n 'event': 'message',\n 'alert': alert,\n 'zulip_message_id': message.id, # message_id is reserved for CCS\n 'time': datetime_to_timestamp(message.pub_date),\n 'content': content,\n 'content_truncated': content_truncated,\n 'sender_email': message.sender.email,\n 'sender_full_name': message.sender.full_name,\n 'sender_avatar_url': get_avatar_url(message.sender.avatar_source, message.sender.email),\n }\n\n if message.recipient.type == Recipient.STREAM:\n android_data['recipient_type'] = \"stream\"\n android_data['stream'] = get_display_recipient(message.recipient)\n android_data['topic'] = message.subject\n elif message.recipient.type in (Recipient.HUDDLE, Recipient.PERSONAL):\n android_data['recipient_type'] = \"private\"\n\n send_android_push_notification(user_profile, android_data)\n\n except UserMessage.DoesNotExist:\n logging.error(\"Could not find UserMessage with message_id %s\" %(missed_message['message_id'],))\n\ndef is_inactive(email):\n try:\n if get_user_profile_by_email(email).is_active:\n raise ValidationError(u'%s is already active' % (email,))\n except UserProfile.DoesNotExist:\n pass\n\ndef user_email_is_unique(email):\n try:\n get_user_profile_by_email(email)\n raise ValidationError(u'%s is already registered' % (email,))\n except UserProfile.DoesNotExist:\n pass\n\ndef do_invite_users(user_profile, invitee_emails, streams):\n new_prereg_users = []\n errors = []\n skipped = []\n\n ret_error = None\n ret_error_data = {} # type: Dict[str, List[Tuple[str, str]]]\n\n for email in invitee_emails:\n if email == '':\n continue\n\n try:\n validators.validate_email(email)\n except ValidationError:\n errors.append((email, \"Invalid address.\"))\n continue\n\n if not email_allowed_for_realm(email, user_profile.realm):\n errors.append((email, \"Outside your domain.\"))\n continue\n\n try:\n existing_user_profile = get_user_profile_by_email(email)\n except UserProfile.DoesNotExist:\n existing_user_profile = None\n try:\n if existing_user_profile is not None and existing_user_profile.is_mirror_dummy:\n # Mirror dummy users to be activated must be inactive\n is_inactive(email)\n else:\n # Other users should not already exist at all.\n user_email_is_unique(email)\n except ValidationError:\n skipped.append((email, \"Already has an account.\"))\n continue\n\n # The logged in user is the referrer.\n prereg_user = PreregistrationUser(email=email, referred_by=user_profile)\n\n # We save twice because you cannot associate a ManyToMany field\n # on an unsaved object.\n prereg_user.save()\n prereg_user.streams = streams\n prereg_user.save()\n\n new_prereg_users.append(prereg_user)\n\n if errors:\n ret_error = \"Some emails did not validate, so we didn't send any invitations.\"\n ret_error_data = {'errors': errors}\n\n if skipped and len(skipped) == len(invitee_emails):\n # All e-mails were skipped, so we didn't actually invite anyone.\n ret_error = \"We weren't able to invite anyone.\"\n ret_error_data = {'errors': skipped}\n return ret_error, ret_error_data\n\n # If we encounter an exception at any point before now, there are no unwanted side-effects,\n # since it is totally fine to have duplicate PreregistrationUsers\n for user in new_prereg_users:\n event = {\"email\": user.email, \"referrer_email\": user_profile.email}\n queue_json_publish(\"invites\", event,\n lambda event: do_send_confirmation_email(user, user_profile))\n\n if skipped:\n ret_error = \"Some of those addresses are already using Zulip, \\\nso we didn't send them an invitation. We did send invitations to everyone else!\"\n ret_error_data = {'errors': skipped}\n\n return ret_error, ret_error_data\n\ndef send_referral_event(user_profile):\n event = dict(type=\"referral\",\n referrals=dict(granted=user_profile.invites_granted,\n used=user_profile.invites_used))\n send_event(event, [user_profile.id])\n\ndef do_refer_friend(user_profile, email):\n content = \"\"\"Referrer: \"%s\" <%s>\nRealm: %s\nReferred: %s\"\"\" % (user_profile.full_name, user_profile.email, user_profile.realm.domain, email)\n subject = \"Zulip referral: %s\" % (email,)\n from_email = '\"%s\" <%s>' % (user_profile.full_name, 'referrals@zulip.com')\n to_email = '\"Zulip Referrals\" <zulip+referrals@zulip.com>'\n headers = {'Reply-To' : '\"%s\" <%s>' % (user_profile.full_name, user_profile.email,)}\n msg = EmailMessage(subject, content, from_email, [to_email], headers=headers)\n msg.send()\n\n referral = Referral(user_profile=user_profile, email=email)\n referral.save()\n user_profile.invites_used += 1\n user_profile.save(update_fields=['invites_used'])\n\n send_referral_event(user_profile)\n\ndef notify_realm_emoji(realm):\n event = dict(type=\"realm_emoji\", op=\"update\",\n realm_emoji=realm.get_emoji())\n user_ids = [userdict['id'] for userdict in get_active_user_dicts_in_realm(realm)]\n send_event(event, user_ids)\n\ndef do_add_realm_emoji(realm, name, img_url):\n RealmEmoji(realm=realm, name=name, img_url=img_url).save()\n notify_realm_emoji(realm)\n\ndef do_remove_realm_emoji(realm, name):\n RealmEmoji.objects.get(realm=realm, name=name).delete()\n notify_realm_emoji(realm)\n\ndef notify_alert_words(user_profile, words):\n event = dict(type=\"alert_words\", alert_words=words)\n send_event(event, [user_profile.id])\n\ndef do_add_alert_words(user_profile, alert_words):\n words = add_user_alert_words(user_profile, alert_words)\n notify_alert_words(user_profile, words)\n\ndef do_remove_alert_words(user_profile, alert_words):\n words = remove_user_alert_words(user_profile, alert_words)\n notify_alert_words(user_profile, words)\n\ndef do_set_alert_words(user_profile, alert_words):\n set_user_alert_words(user_profile, alert_words)\n notify_alert_words(user_profile, alert_words)\n\ndef do_set_muted_topics(user_profile, muted_topics):\n user_profile.muted_topics = ujson.dumps(muted_topics)\n user_profile.save(update_fields=['muted_topics'])\n event = dict(type=\"muted_topics\", muted_topics=muted_topics)\n send_event(event, [user_profile.id])\n\ndef notify_realm_filters(realm):\n realm_filters = realm_filters_for_domain(realm.domain)\n user_ids = [userdict['id'] for userdict in get_active_user_dicts_in_realm(realm)]\n event = dict(type=\"realm_filters\", realm_filters=realm_filters)\n send_event(event, user_ids)\n\n# NOTE: Regexes must be simple enough that they can be easily translated to JavaScript\n# RegExp syntax. In addition to JS-compatible syntax, the following features are available:\n# * Named groups will be converted to numbered groups automatically\n# * Inline-regex flags will be stripped, and where possible translated to RegExp-wide flags\ndef do_add_realm_filter(realm, pattern, url_format_string):\n RealmFilter(realm=realm, pattern=pattern,\n url_format_string=url_format_string).save()\n notify_realm_filters(realm)\n\ndef do_remove_realm_filter(realm, pattern):\n RealmFilter.objects.get(realm=realm, pattern=pattern).delete()\n notify_realm_filters(realm)\n\ndef get_emails_from_user_ids(user_ids):\n # We may eventually use memcached to speed this up, but the DB is fast.\n return UserProfile.emails_from_ids(user_ids)\n\ndef realm_aliases(realm):\n return [alias.domain for alias in realm.realmalias_set.all()]\n\ndef get_occupied_streams(realm):\n \"\"\" Get streams with subscribers \"\"\"\n subs_filter = Subscription.objects.filter(active=True, user_profile__realm=realm,\n user_profile__is_active=True).values('recipient_id')\n stream_ids = Recipient.objects.filter(\n type=Recipient.STREAM, id__in=subs_filter).values('type_id')\n\n return Stream.objects.filter(id__in=stream_ids, realm=realm, deactivated=False)\n\ndef do_get_streams(user_profile, include_public=True, include_subscribed=True,\n include_all_active=False):\n if include_all_active and not user_profile.is_api_super_user():\n raise JsonableError(\"User not authorized for this query\")\n\n # Listing public streams are disabled for the mit.edu realm.\n include_public = include_public and user_profile.realm.domain != \"mit.edu\"\n # Start out with all streams in the realm with subscribers\n query = get_occupied_streams(user_profile.realm)\n\n if not include_all_active:\n user_subs = Subscription.objects.select_related(\"recipient\").filter(\n active=True, user_profile=user_profile,\n recipient__type=Recipient.STREAM)\n\n if include_subscribed:\n recipient_check = Q(id__in=[sub.recipient.type_id for sub in user_subs])\n if include_public:\n invite_only_check = Q(invite_only=False)\n\n if include_subscribed and include_public:\n query = query.filter(recipient_check | invite_only_check)\n elif include_public:\n query = query.filter(invite_only_check)\n elif include_subscribed:\n query = query.filter(recipient_check)\n else:\n # We're including nothing, so don't bother hitting the DB.\n query = []\n\n def make_dict(row):\n return dict(\n stream_id = row.id,\n name = row.name,\n description = row.description,\n invite_only = row.invite_only,\n )\n\n streams = [make_dict(row) for row in query]\n streams.sort(key=lambda elt: elt[\"name\"])\n\n return streams\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227598,"cells":{"text":{"kind":"string","value":"# coding: utf-8\n\n\"\"\"\nRedfishvApi.py\nCopyright 2015 SmartBear Software\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\"\"\"\n\nfrom __future__ import absolute_import\n\nimport sys\nimport os\n\n# python 2 and python 3 compatibility library\nfrom six import iteritems\n\nfrom ..configuration import Configuration\nfrom ..api_client import ApiClient\n\n\nclass RedfishvApi(object):\n \"\"\"\n NOTE: This class is auto generated by the swagger code generator program.\n Do not edit the class manually.\n Ref: https://github.com/swagger-api/swagger-codegen\n \"\"\"\n\n def __init__(self, api_client=None):\n config = Configuration()\n if api_client:\n self.api_client = api_client\n else:\n if not config.api_client:\n config.api_client = ApiClient()\n self.api_client = config.api_client\n\n def get_service_root(self, **kwargs):\n \"\"\"\n retrieve list of root-level resources\n This object represents the root Redfish service. All values for resources described by this schema shall comply to the requirements as described in the Redfish specification. This object represents the root Redfish service.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_service_root(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: ServiceRoot100ServiceRoot\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_service_root\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='ServiceRoot100ServiceRoot',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented(self, **kwargs):\n \"\"\"\n retrieve account service information\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: AccountService100AccountService\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/AccountService'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='AccountService100AccountService',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def list_chassis(self, **kwargs):\n \"\"\"\n retrieve list of physical components\n Defines a collection of physical components managed by the service\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.list_chassis(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: ChassisCollectionChassisCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method list_chassis\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/Chassis'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='ChassisCollectionChassisCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def get_chassis(self, identifier, **kwargs):\n \"\"\"\n retrieve specific information for a physical component\n Retrieves a detailed information catalog for the physical component specified by identifier\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_chassis(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: Chassis100Chassis\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_chassis\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `get_chassis`\")\n\n resource_path = '/Chassis/{identifier}'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='Chassis100Chassis',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def get_power(self, identifier, **kwargs):\n \"\"\"\n Retrieve power characteristics of a chassis\n defines a collection of power elements contained within a resource.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_power(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: Power100Power\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_power\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `get_power`\")\n\n resource_path = '/Chassis/{identifier}/Power'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='Power100Power',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def get_thermal(self, identifier, **kwargs):\n \"\"\"\n Retrieve thermal characteristics of a chassis\n defines a collection of thermal elements contained within a resource.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_thermal(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: Thermal100Thermal\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_thermal\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `get_thermal`\")\n\n resource_path = '/Chassis/{identifier}/Thermal'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='Thermal100Thermal',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented_1(self, **kwargs):\n \"\"\"\n retrieve list of policies used by event service listeners\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented_1(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: AccountService100AccountService\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented_1\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/EventService'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='AccountService100AccountService',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented_2(self, **kwargs):\n \"\"\"\n retrieve list of manager accounts\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented_2(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: ManagerAccountCollectionManagerAccountCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented_2\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/ManagerAccounts'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='ManagerAccountCollectionManagerAccountCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented_3(self, identifier, **kwargs):\n \"\"\"\n retrieve a manager account by name\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented_3(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: ManagerAccount100ManagerAccount\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented_3\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `unimplemented_3`\")\n\n resource_path = '/ManagerAccounts/{identifier}'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='ManagerAccount100ManagerAccount',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented_4(self, **kwargs):\n \"\"\"\n retrieve list of management servers\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented_4(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: ManagerCollectionManagerCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented_4\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/Managers'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='ManagerCollectionManagerCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented_5(self, identifier, **kwargs):\n \"\"\"\n retrieve list of management servers\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented_5(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: Manager100Manager\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented_5\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `unimplemented_5`\")\n\n resource_path = '/Managers/{identifier}'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='Manager100Manager',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented_6(self, **kwargs):\n \"\"\"\n Unspecified\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented_6(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: MessageRegistryMessageRegistry\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented_6\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/Registries'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='MessageRegistryMessageRegistry',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented_7(self, **kwargs):\n \"\"\"\n retrieve list of roles for use in ManagerAccounts\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented_7(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: RoleCollectionRoleCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented_7\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/Roles'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='RoleCollectionRoleCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented_8(self, identifier, **kwargs):\n \"\"\"\n retrieve a manager account role by name\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented_8(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: Role100Role\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented_8\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `unimplemented_8`\")\n\n resource_path = '/Roles/{identifier}'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='Role100Role',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented_9(self, **kwargs):\n \"\"\"\n Unspecified\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented_9(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: JsonSchemaFileCollectionJsonSchemaFileCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented_9\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/Schemas'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='JsonSchemaFileCollectionJsonSchemaFileCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def unimplemented_10(self, **kwargs):\n \"\"\"\n retrieve a list of sessions\n \n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.unimplemented_10(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: SessionService100SessionService\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method unimplemented_10\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/Sessions'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='SessionService100SessionService',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def list_systems(self, **kwargs):\n \"\"\"\n retrieve list of computer systems\n retrieve list of computer systems\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.list_systems(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: ComputerSystemCollectionComputerSystemCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method list_systems\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/Systems'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='ComputerSystemCollectionComputerSystemCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def get_system(self, identifier, **kwargs):\n \"\"\"\n retrieve information for a specific computer systems (physical and/or virtual)\n defines a computer system and its respective properties. A computer system represents a machine (physical or virtual) and the local resources such as memory, cpu and other devices that can be accessed from that machine.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_system(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: node identifier (required)\n :return: ComputerSystem100ComputerSystem\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_system\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `get_system`\")\n\n resource_path = '/Systems/{identifier}'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='ComputerSystem100ComputerSystem',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def list_reset_types(self, identifier, **kwargs):\n \"\"\"\n retrieve the list of reset types for the specified compute node\n Retrieve a list of valid reset types for the system described by identifier\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.list_reset_types(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: RackHDResetAction\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method list_reset_types\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `list_reset_types`\")\n\n resource_path = '/Systems/{identifier}/Actions/ComputerSystem.Reset'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='RackHDResetAction',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def do_reset(self, identifier, payload, **kwargs):\n \"\"\"\n reset a node\n Perform the reset specified in the post data arguments on the system described by identifier\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.do_reset(identifier, payload, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :param RackHDResetAction payload: (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier', 'payload']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method do_reset\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `do_reset`\")\n # verify the required parameter 'payload' is set\n if ('payload' not in params) or (params['payload'] is None):\n raise ValueError(\"Missing the required parameter `payload` when calling `do_reset`\")\n\n resource_path = '/Systems/{identifier}/Actions/ComputerSystem.Reset'.replace('{format}', 'json')\n method = 'POST'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n if 'payload' in params:\n body_params = params['payload']\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type=None,\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def list_boot_image(self, identifier, **kwargs):\n \"\"\"\n retrieve the list of boot image types for the specified compute node\n Retrieve a list of valid boot image types for the system described by identifier\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.list_boot_image(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: RackHDBootImageBootImageList\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method list_boot_image\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `list_boot_image`\")\n\n resource_path = '/Systems/{identifier}/Actions/RackHD.BootImage'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='RackHDBootImageBootImageList',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def do_boot_image(self, identifier, payload, **kwargs):\n \"\"\"\n install a boot image on a node\n Perform the boot image installation specified in the post data arguments on the system described by identifier\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.do_boot_image(identifier, payload, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :param RackHDBootImageBootImage payload: (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier', 'payload']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method do_boot_image\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `do_boot_image`\")\n # verify the required parameter 'payload' is set\n if ('payload' not in params) or (params['payload'] is None):\n raise ValueError(\"Missing the required parameter `payload` when calling `do_boot_image`\")\n\n resource_path = '/Systems/{identifier}/Actions/RackHD.BootImage'.replace('{format}', 'json')\n method = 'POST'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n if 'payload' in params:\n body_params = params['payload']\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type=None,\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def list_log_service(self, identifier, **kwargs):\n \"\"\"\n retrieve list of the logs for a computer system\n Defines a collection of log services that are available for the system described by identifier\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.list_log_service(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: LogServiceCollectionLogServiceCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method list_log_service\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `list_log_service`\")\n\n resource_path = '/Systems/{identifier}/LogServices'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='LogServiceCollectionLogServiceCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def get_sel_log_service(self, identifier, **kwargs):\n \"\"\"\n retrieve list of the logs for a computer system\n Defines a collection of SEL entries for the system described by identifier.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_sel_log_service(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: LogService100LogService\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_sel_log_service\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `get_sel_log_service`\")\n\n resource_path = '/Systems/{identifier}/LogServices/sel'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='LogService100LogService',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def list_sel_log_service_entries(self, identifier, **kwargs):\n \"\"\"\n retrieve list of the logs entries for associated for log service\n Defines a collection of entries for the system described by identifier\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.list_sel_log_service_entries(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: LogEntryCollectionLogEntryCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method list_sel_log_service_entries\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `list_sel_log_service_entries`\")\n\n resource_path = '/Systems/{identifier}/LogServices/sel/Entries'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='LogEntryCollectionLogEntryCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def get_sel_log_service_entry(self, identifier, entry_id, **kwargs):\n \"\"\"\n retrieve log entry by logId associated for log service\n Defines a log entry specified by entryId within the LogService of the specified type for the system described by identifier\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_sel_log_service_entry(identifier, entry_id, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :param str entry_id: (required)\n :return: LogEntry100LogEntry\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier', 'entry_id']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_sel_log_service_entry\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `get_sel_log_service_entry`\")\n # verify the required parameter 'entry_id' is set\n if ('entry_id' not in params) or (params['entry_id'] is None):\n raise ValueError(\"Missing the required parameter `entry_id` when calling `get_sel_log_service_entry`\")\n\n resource_path = '/Systems/{identifier}/LogServices/sel/Entries/{entryId}'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n if 'entry_id' in params:\n path_params['entryId'] = params['entry_id']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='LogEntry100LogEntry',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def list_system_processors(self, identifier, **kwargs):\n \"\"\"\n retrieve the processor collection for the specified system identifier\n defines a collection of processors contained within a resource.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.list_system_processors(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: ProcessorCollectionProcessorCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method list_system_processors\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `list_system_processors`\")\n\n resource_path = '/Systems/{identifier}/Processors'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='ProcessorCollectionProcessorCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def get_system_processor(self, identifier, socket, **kwargs):\n \"\"\"\n retrieve a specified processor for the specified system identifier\n This represents the properties of a processor attached to a System.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_system_processor(identifier, socket, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :param str socket: (required)\n :return: Processor100Processor\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier', 'socket']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_system_processor\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `get_system_processor`\")\n # verify the required parameter 'socket' is set\n if ('socket' not in params) or (params['socket'] is None):\n raise ValueError(\"Missing the required parameter `socket` when calling `get_system_processor`\")\n\n resource_path = '/Systems/{identifier}/Processors/{socket}'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n if 'socket' in params:\n path_params['socket'] = params['socket']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='Processor100Processor',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def list_simple_storage(self, identifier, **kwargs):\n \"\"\"\n retrieve the simple storage collection\n Defines a collection of simple storage collections that are present on the system described by identifier\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.list_simple_storage(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: SimpleStorageCollectionSimpleStorageCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method list_simple_storage\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `list_simple_storage`\")\n\n resource_path = '/Systems/{identifier}/SimpleStorage'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='SimpleStorageCollectionSimpleStorageCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def get_simple_storage(self, identifier, index, **kwargs):\n \"\"\"\n Retrieve the simple storage collection by device identifier\n Defines a collection of storage devices on the device specified by identifier that are present on the system described by identifier\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_simple_storage(identifier, index, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :param str index: (required)\n :return: SimpleStorage100SimpleStorage\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier', 'index']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_simple_storage\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `get_simple_storage`\")\n # verify the required parameter 'index' is set\n if ('index' not in params) or (params['index'] is None):\n raise ValueError(\"Missing the required parameter `index` when calling `get_simple_storage`\")\n\n resource_path = '/Systems/{identifier}/SimpleStorage/{index}'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n if 'index' in params:\n path_params['index'] = params['index']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='SimpleStorage100SimpleStorage',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def task_service_root(self, **kwargs):\n \"\"\"\n retrieve list of all tasks\n This object represents the root Redfish service.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.task_service_root(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: TaskService100TaskService\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method task_service_root\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/TaskService'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='TaskService100TaskService',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def get_system_tasks(self, identifier, **kwargs):\n \"\"\"\n retrieve list of tasks per system Id\n This object represents the root Redfish service.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_system_tasks(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: TaskCollectionTaskCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_system_tasks\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `get_system_tasks`\")\n\n resource_path = '/TaskService/Oem/Tasks/{identifier}'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='TaskCollectionTaskCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def list_tasks(self, **kwargs):\n \"\"\"\n retrieve list of all tasks\n This object represents the root Redfish service.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.list_tasks(callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :return: TaskCollectionTaskCollection\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = []\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method list_tasks\" % key\n )\n params[key] = val\n del params['kwargs']\n\n\n resource_path = '/TaskService/Tasks'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='TaskCollectionTaskCollection',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n\n def get_task(self, identifier, **kwargs):\n \"\"\"\n retrieve a task entry by task Id\n This object represents the root Redfish service.\n\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please define a `callback` function\n to be invoked when receiving the response.\n >>> def callback_function(response):\n >>> pprint(response)\n >>>\n >>> thread = api.get_task(identifier, callback=callback_function)\n\n :param callback function: The callback function\n for asynchronous request. (optional)\n :param str identifier: (required)\n :return: Task100Task\n If the method is called asynchronously,\n returns the request thread.\n \"\"\"\n\n all_params = ['identifier']\n all_params.append('callback')\n\n params = locals()\n for key, val in iteritems(params['kwargs']):\n if key not in all_params:\n raise TypeError(\n \"Got an unexpected keyword argument '%s'\"\n \" to method get_task\" % key\n )\n params[key] = val\n del params['kwargs']\n\n # verify the required parameter 'identifier' is set\n if ('identifier' not in params) or (params['identifier'] is None):\n raise ValueError(\"Missing the required parameter `identifier` when calling `get_task`\")\n\n resource_path = '/TaskService/Tasks/{identifier}'.replace('{format}', 'json')\n method = 'GET'\n\n path_params = {}\n if 'identifier' in params:\n path_params['identifier'] = params['identifier']\n\n query_params = {}\n\n header_params = {}\n\n form_params = {}\n files = {}\n\n body_params = None\n\n # HTTP header `Accept`\n header_params['Accept'] = self.api_client.\\\n select_header_accept(['application/json'])\n if not header_params['Accept']:\n del header_params['Accept']\n\n # HTTP header `Content-Type`\n header_params['Content-Type'] = self.api_client.\\\n select_header_content_type(['application/json'])\n\n # Authentication setting\n auth_settings = []\n\n response = self.api_client.call_api(resource_path, method,\n path_params,\n query_params,\n header_params,\n body=body_params,\n post_params=form_params,\n files=files,\n response_type='Task100Task',\n auth_settings=auth_settings,\n callback=params.get('callback'))\n return response\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227599,"cells":{"text":{"kind":"string","value":"# Copyright (c) Gary Strangman. All rights reserved\n#\n# Disclaimer\n#\n# This software is provided \"as-is\". There are no expressed or implied\n# warranties of any kind, including, but not limited to, the warranties\n# of merchantability and fitness for a given application. In no event\n# shall Gary Strangman be liable for any direct, indirect, incidental,\n# special, exemplary or consequential damages (including, but not limited\n# to, loss of use, data or profits, or business interruption) however\n# caused and on any theory of liability, whether in contract, strict\n# liability or tort (including negligence or otherwise) arising in any way\n# out of the use of this software, even if advised of the possibility of\n# such damage.\n#\n\n#\n# Heavily adapted for use by SciPy 2002 by Travis Oliphant\n\"\"\"\nA collection of basic statistical functions for python. The function\nnames appear below.\n\n Some scalar functions defined here are also available in the scipy.special\n package where they work on arbitrary sized arrays.\n\nDisclaimers: The function list is obviously incomplete and, worse, the\nfunctions are not optimized. All functions have been tested (some more\nso than others), but they are far from bulletproof. Thus, as with any\nfree software, no warranty or guarantee is expressed or implied. :-) A\nfew extra functions that don't appear in the list below can be found by\ninterested treasure-hunters. These functions don't necessarily have\nboth list and array versions but were deemed useful.\n\nCentral Tendency\n----------------\n.. autosummary::\n :toctree: generated/\n\n gmean\n hmean\n mode\n\nMoments\n-------\n.. autosummary::\n :toctree: generated/\n\n moment\n variation\n skew\n kurtosis\n normaltest\n\nMoments Handling NaN:\n\n.. autosummary::\n :toctree: generated/\n\n nanmean\n nanmedian\n nanstd\n\nAltered Versions\n----------------\n.. autosummary::\n :toctree: generated/\n\n tmean\n tvar\n tstd\n tsem\n describe\n\nFrequency Stats\n---------------\n.. autosummary::\n :toctree: generated/\n\n itemfreq\n scoreatpercentile\n percentileofscore\n histogram\n cumfreq\n relfreq\n\nVariability\n-----------\n.. autosummary::\n :toctree: generated/\n\n obrientransform\n signaltonoise\n sem\n\nTrimming Functions\n------------------\n.. autosummary::\n :toctree: generated/\n\n threshold\n trimboth\n trim1\n\nCorrelation Functions\n---------------------\n.. autosummary::\n :toctree: generated/\n\n pearsonr\n fisher_exact\n spearmanr\n pointbiserialr\n kendalltau\n linregress\n theilslopes\n\nInferential Stats\n-----------------\n.. autosummary::\n :toctree: generated/\n\n ttest_1samp\n ttest_ind\n ttest_rel\n chisquare\n power_divergence\n ks_2samp\n mannwhitneyu\n ranksums\n wilcoxon\n kruskal\n friedmanchisquare\n combine_pvalues\n\nProbability Calculations\n------------------------\n.. autosummary::\n :toctree: generated/\n\n chisqprob\n zprob\n fprob\n betai\n\nANOVA Functions\n---------------\n.. autosummary::\n :toctree: generated/\n\n f_oneway\n f_value\n\nSupport Functions\n-----------------\n.. autosummary::\n :toctree: generated/\n\n ss\n square_of_sums\n rankdata\n\nReferences\n----------\n.. [CRCProbStat2000] Zwillinger, D. and Kokoska, S. (2000). CRC Standard\n Probability and Statistics Tables and Formulae. Chapman & Hall: New\n York. 2000.\n\n\"\"\"\n\nfrom __future__ import division, print_function, absolute_import\n\nimport warnings\nimport math\nfrom collections import namedtuple\n\nfrom scipy.lib.six import xrange\n\n# friedmanchisquare patch uses python sum\npysum = sum # save it before it gets overwritten\n\n# Scipy imports.\nfrom scipy.lib.six import callable, string_types\nfrom numpy import array, asarray, ma, zeros, sum\nimport scipy.special as special\nimport scipy.linalg as linalg\nimport numpy as np\n\nfrom . import futil\nfrom . import distributions\n\nfrom ._rank import rankdata, tiecorrect\n\n__all__ = ['find_repeats', 'gmean', 'hmean', 'mode', 'tmean', 'tvar',\n 'tmin', 'tmax', 'tstd', 'tsem', 'moment', 'variation',\n 'skew', 'kurtosis', 'describe', 'skewtest', 'kurtosistest',\n 'normaltest', 'jarque_bera', 'itemfreq',\n 'scoreatpercentile', 'percentileofscore', 'histogram',\n 'histogram2', 'cumfreq', 'relfreq', 'obrientransform',\n 'signaltonoise', 'sem', 'zmap', 'zscore', 'threshold',\n 'sigmaclip', 'trimboth', 'trim1', 'trim_mean', 'f_oneway',\n 'pearsonr', 'fisher_exact', 'spearmanr', 'pointbiserialr',\n 'kendalltau', 'linregress', 'theilslopes', 'ttest_1samp',\n 'ttest_ind', 'ttest_rel', 'kstest', 'chisquare',\n 'power_divergence', 'ks_2samp', 'mannwhitneyu',\n 'tiecorrect', 'ranksums', 'kruskal', 'friedmanchisquare',\n 'zprob', 'chisqprob', 'ksprob', 'fprob', 'betai',\n 'f_value_wilks_lambda', 'f_value', 'f_value_multivariate',\n 'ss', 'square_of_sums', 'fastsort', 'rankdata', 'nanmean',\n 'nanstd', 'nanmedian', 'combine_pvalues', ]\n\n\ndef _chk_asarray(a, axis):\n if axis is None:\n a = np.ravel(a)\n outaxis = 0\n else:\n a = np.asarray(a)\n outaxis = axis\n return a, outaxis\n\n\ndef _chk2_asarray(a, b, axis):\n if axis is None:\n a = np.ravel(a)\n b = np.ravel(b)\n outaxis = 0\n else:\n a = np.asarray(a)\n b = np.asarray(b)\n outaxis = axis\n return a, b, outaxis\n\n\ndef find_repeats(arr):\n \"\"\"\n Find repeats and repeat counts.\n\n Parameters\n ----------\n arr : array_like\n Input array\n\n Returns\n -------\n find_repeats : tuple\n Returns a tuple of two 1-D ndarrays. The first ndarray are the repeats\n as sorted, unique values that are repeated in `arr`. The second\n ndarray are the counts mapped one-to-one of the repeated values\n in the first ndarray.\n\n Examples\n --------\n >>> from scipy import stats\n >>> stats.find_repeats([2, 1, 2, 3, 2, 2, 5])\n (array([ 2. ]), array([ 4 ], dtype=int32)\n\n >>> stats.find_repeats([[10, 20, 1, 2], [5, 5, 4, 4]])\n (array([ 4., 5.]), array([2, 2], dtype=int32))\n\n \"\"\"\n v1, v2, n = futil.dfreps(arr)\n return v1[:n], v2[:n]\n\n#######\n### NAN friendly functions\n########\n\n\n@np.deprecate(message=\"scipy.stats.nanmean is deprecated in scipy 0.15.0 \"\n \"in favour of numpy.nanmean.\")\ndef nanmean(x, axis=0):\n \"\"\"\n Compute the mean over the given axis ignoring nans.\n\n Parameters\n ----------\n x : ndarray\n Input array.\n axis : int, optional\n Axis along which the mean is computed. Default is 0, i.e. the\n first axis.\n\n Returns\n -------\n m : float\n The mean of `x`, ignoring nans.\n\n See Also\n --------\n nanstd, nanmedian\n\n Examples\n --------\n >>> from scipy import stats\n >>> a = np.linspace(0, 4, 3)\n >>> a\n array([ 0., 2., 4.])\n >>> a[-1] = np.nan\n >>> stats.nanmean(a)\n 1.0\n\n \"\"\"\n x, axis = _chk_asarray(x, axis)\n x = x.copy()\n Norig = x.shape[axis]\n mask = np.isnan(x)\n factor = 1.0 - np.sum(mask, axis) / Norig\n\n x[mask] = 0.0\n return np.mean(x, axis) / factor\n\n\n@np.deprecate(message=\"scipy.stats.nanstd is deprecated in scipy 0.15 \"\n \"in favour of numpy.nanstd.\\nNote that numpy.nanstd \"\n \"has a different signature.\")\ndef nanstd(x, axis=0, bias=False):\n \"\"\"\n Compute the standard deviation over the given axis, ignoring nans.\n\n Parameters\n ----------\n x : array_like\n Input array.\n axis : int or None, optional\n Axis along which the standard deviation is computed. Default is 0.\n If None, compute over the whole array `x`.\n bias : bool, optional\n If True, the biased (normalized by N) definition is used. If False\n (default), the unbiased definition is used.\n\n Returns\n -------\n s : float\n The standard deviation.\n\n See Also\n --------\n nanmean, nanmedian\n\n Examples\n --------\n >>> from scipy import stats\n >>> a = np.arange(10, dtype=float)\n >>> a[1:3] = np.nan\n >>> np.std(a)\n nan\n >>> stats.nanstd(a)\n 2.9154759474226504\n >>> stats.nanstd(a.reshape(2, 5), axis=1)\n array([ 2.0817, 1.5811])\n >>> stats.nanstd(a.reshape(2, 5), axis=None)\n 2.9154759474226504\n\n \"\"\"\n x, axis = _chk_asarray(x, axis)\n x = x.copy()\n Norig = x.shape[axis]\n\n mask = np.isnan(x)\n Nnan = np.sum(mask, axis) * 1.0\n n = Norig - Nnan\n\n x[mask] = 0.0\n m1 = np.sum(x, axis) / n\n\n if axis:\n d = x - np.expand_dims(m1, axis)\n else:\n d = x - m1\n\n d *= d\n\n m2 = np.sum(d, axis) - m1 * m1 * Nnan\n\n if bias:\n m2c = m2 / n\n else:\n m2c = m2 / (n - 1.0)\n\n return np.sqrt(m2c)\n\n\ndef _nanmedian(arr1d): # This only works on 1d arrays\n \"\"\"Private function for rank a arrays. Compute the median ignoring Nan.\n\n Parameters\n ----------\n arr1d : ndarray\n Input array, of rank 1.\n\n Results\n -------\n m : float\n The median.\n \"\"\"\n x = arr1d.copy()\n c = np.isnan(x)\n s = np.where(c)[0]\n if s.size == x.size:\n warnings.warn(\"All-NaN slice encountered\", RuntimeWarning)\n return np.nan\n elif s.size != 0:\n # select non-nans at end of array\n enonan = x[-s.size:][~c[-s.size:]]\n # fill nans in beginning of array with non-nans of end\n x[s[:enonan.size]] = enonan\n # slice nans away\n x = x[:-s.size]\n return np.median(x, overwrite_input=True)\n\n@np.deprecate(message=\"scipy.stats.nanmedian is deprecated in scipy 0.15 \"\n \"in favour of numpy.nanmedian.\")\ndef nanmedian(x, axis=0):\n \"\"\"\n Compute the median along the given axis ignoring nan values.\n\n Parameters\n ----------\n x : array_like\n Input array.\n axis : int, optional\n Axis along which the median is computed. Default is 0, i.e. the\n first axis.\n\n Returns\n -------\n m : float\n The median of `x` along `axis`.\n\n See Also\n --------\n nanstd, nanmean, numpy.nanmedian\n\n Examples\n --------\n >>> from scipy import stats\n >>> a = np.array([0, 3, 1, 5, 5, np.nan])\n >>> stats.nanmedian(a)\n array(3.0)\n\n >>> b = np.array([0, 3, 1, 5, 5, np.nan, 5])\n >>> stats.nanmedian(b)\n array(4.0)\n\n Example with axis:\n\n >>> c = np.arange(30.).reshape(5,6)\n >>> idx = np.array([False, False, False, True, False] * 6).reshape(5,6)\n >>> c[idx] = np.nan\n >>> c\n array([[ 0., 1., 2., nan, 4., 5.],\n [ 6., 7., nan, 9., 10., 11.],\n [ 12., nan, 14., 15., 16., 17.],\n [ nan, 19., 20., 21., 22., nan],\n [ 24., 25., 26., 27., nan, 29.]])\n >>> stats.nanmedian(c, axis=1)\n array([ 2. , 9. , 15. , 20.5, 26. ])\n\n \"\"\"\n x, axis = _chk_asarray(x, axis)\n if x.ndim == 0:\n return float(x.item())\n if hasattr(np, 'nanmedian'): # numpy 1.9 faster for some cases\n return np.nanmedian(x, axis)\n x = np.apply_along_axis(_nanmedian, axis, x)\n if x.ndim == 0:\n x = float(x.item())\n return x\n\n\n#####################################\n######## CENTRAL TENDENCY ########\n#####################################\n\n\ndef gmean(a, axis=0, dtype=None):\n \"\"\"\n Compute the geometric mean along the specified axis.\n\n Returns the geometric average of the array elements.\n That is: n-th root of (x1 * x2 * ... * xn)\n\n Parameters\n ----------\n a : array_like\n Input array or object that can be converted to an array.\n axis : int, optional, default axis=0\n Axis along which the geometric mean is computed.\n dtype : dtype, optional\n Type of the returned array and of the accumulator in which the\n elements are summed. If dtype is not specified, it defaults to the\n dtype of a, unless a has an integer dtype with a precision less than\n that of the default platform integer. In that case, the default\n platform integer is used.\n\n Returns\n -------\n gmean : ndarray\n see dtype parameter above\n\n See Also\n --------\n numpy.mean : Arithmetic average\n numpy.average : Weighted average\n hmean : Harmonic mean\n\n Notes\n -----\n The geometric average is computed over a single dimension of the input\n array, axis=0 by default, or all values in the array if axis=None.\n float64 intermediate and return values are used for integer inputs.\n\n Use masked arrays to ignore any non-finite values in the input or that\n arise in the calculations such as Not a Number and infinity because masked\n arrays automatically mask any non-finite values.\n\n \"\"\"\n if not isinstance(a, np.ndarray): # if not an ndarray object attempt to convert it\n log_a = np.log(np.array(a, dtype=dtype))\n elif dtype: # Must change the default dtype allowing array type\n if isinstance(a, np.ma.MaskedArray):\n log_a = np.log(np.ma.asarray(a, dtype=dtype))\n else:\n log_a = np.log(np.asarray(a, dtype=dtype))\n else:\n log_a = np.log(a)\n return np.exp(log_a.mean(axis=axis))\n\n\ndef hmean(a, axis=0, dtype=None):\n \"\"\"\n Calculates the harmonic mean along the specified axis.\n\n That is: n / (1/x1 + 1/x2 + ... + 1/xn)\n\n Parameters\n ----------\n a : array_like\n Input array, masked array or object that can be converted to an array.\n axis : int, optional, default axis=0\n Axis along which the harmonic mean is computed.\n dtype : dtype, optional\n Type of the returned array and of the accumulator in which the\n elements are summed. If `dtype` is not specified, it defaults to the\n dtype of `a`, unless `a` has an integer `dtype` with a precision less\n than that of the default platform integer. In that case, the default\n platform integer is used.\n\n Returns\n -------\n hmean : ndarray\n see `dtype` parameter above\n\n See Also\n --------\n numpy.mean : Arithmetic average\n numpy.average : Weighted average\n gmean : Geometric mean\n\n Notes\n -----\n The harmonic mean is computed over a single dimension of the input\n array, axis=0 by default, or all values in the array if axis=None.\n float64 intermediate and return values are used for integer inputs.\n\n Use masked arrays to ignore any non-finite values in the input or that\n arise in the calculations such as Not a Number and infinity.\n\n \"\"\"\n if not isinstance(a, np.ndarray):\n a = np.array(a, dtype=dtype)\n if np.all(a > 0): # Harmonic mean only defined if greater than zero\n if isinstance(a, np.ma.MaskedArray):\n size = a.count(axis)\n else:\n if axis is None:\n a = a.ravel()\n size = a.shape[0]\n else:\n size = a.shape[axis]\n return size / np.sum(1.0/a, axis=axis, dtype=dtype)\n else:\n raise ValueError(\"Harmonic mean only defined if all elements greater than zero\")\n\n\ndef mode(a, axis=0):\n \"\"\"\n Returns an array of the modal (most common) value in the passed array.\n\n If there is more than one such value, only the first is returned.\n The bin-count for the modal bins is also returned.\n\n Parameters\n ----------\n a : array_like\n n-dimensional array of which to find mode(s).\n axis : int, optional\n Axis along which to operate. Default is 0, i.e. the first axis.\n\n Returns\n -------\n vals : ndarray\n Array of modal values.\n counts : ndarray\n Array of counts for each mode.\n\n Examples\n --------\n >>> a = np.array([[6, 8, 3, 0],\n [3, 2, 1, 7],\n [8, 1, 8, 4],\n [5, 3, 0, 5],\n [4, 7, 5, 9]])\n >>> from scipy import stats\n >>> stats.mode(a)\n (array([[ 3., 1., 0., 0.]]), array([[ 1., 1., 1., 1.]]))\n\n To get mode of whole array, specify axis=None:\n\n >>> stats.mode(a, axis=None)\n (array([ 3.]), array([ 3.]))\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n scores = np.unique(np.ravel(a)) # get ALL unique values\n testshape = list(a.shape)\n testshape[axis] = 1\n oldmostfreq = np.zeros(testshape, dtype=a.dtype)\n oldcounts = np.zeros(testshape)\n for score in scores:\n template = (a == score)\n counts = np.expand_dims(np.sum(template, axis), axis)\n mostfrequent = np.where(counts > oldcounts, score, oldmostfreq)\n oldcounts = np.maximum(counts, oldcounts)\n oldmostfreq = mostfrequent\n return mostfrequent, oldcounts\n\n\ndef mask_to_limits(a, limits, inclusive):\n \"\"\"Mask an array for values outside of given limits.\n\n This is primarily a utility function.\n\n Parameters\n ----------\n a : array\n limits : (float or None, float or None)\n A tuple consisting of the (lower limit, upper limit). Values in the\n input array less than the lower limit or greater than the upper limit\n will be masked out. None implies no limit.\n inclusive : (bool, bool)\n A tuple consisting of the (lower flag, upper flag). These flags\n determine whether values exactly equal to lower or upper are allowed.\n\n Returns\n -------\n A MaskedArray.\n\n Raises\n ------\n A ValueError if there are no values within the given limits.\n \"\"\"\n lower_limit, upper_limit = limits\n lower_include, upper_include = inclusive\n am = ma.MaskedArray(a)\n if lower_limit is not None:\n if lower_include:\n am = ma.masked_less(am, lower_limit)\n else:\n am = ma.masked_less_equal(am, lower_limit)\n\n if upper_limit is not None:\n if upper_include:\n am = ma.masked_greater(am, upper_limit)\n else:\n am = ma.masked_greater_equal(am, upper_limit)\n\n if am.count() == 0:\n raise ValueError(\"No array values within given limits\")\n\n return am\n\n\ndef tmean(a, limits=None, inclusive=(True, True)):\n \"\"\"\n Compute the trimmed mean.\n\n This function finds the arithmetic mean of given values, ignoring values\n outside the given `limits`.\n\n Parameters\n ----------\n a : array_like\n Array of values.\n limits : None or (lower limit, upper limit), optional\n Values in the input array less than the lower limit or greater than the\n upper limit will be ignored. When limits is None (default), then all\n values are used. Either of the limit values in the tuple can also be\n None representing a half-open interval.\n inclusive : (bool, bool), optional\n A tuple consisting of the (lower flag, upper flag). These flags\n determine whether values exactly equal to the lower or upper limits\n are included. The default value is (True, True).\n\n Returns\n -------\n tmean : float\n\n \"\"\"\n a = asarray(a)\n if limits is None:\n return np.mean(a, None)\n\n am = mask_to_limits(a.ravel(), limits, inclusive)\n return am.mean()\n\n\ndef masked_var(am):\n m = am.mean()\n s = ma.add.reduce((am - m)**2)\n n = am.count() - 1.0\n return s / n\n\n\ndef tvar(a, limits=None, inclusive=(True, True)):\n \"\"\"\n Compute the trimmed variance\n\n This function computes the sample variance of an array of values,\n while ignoring values which are outside of given `limits`.\n\n Parameters\n ----------\n a : array_like\n Array of values.\n limits : None or (lower limit, upper limit), optional\n Values in the input array less than the lower limit or greater than the\n upper limit will be ignored. When limits is None, then all values are\n used. Either of the limit values in the tuple can also be None\n representing a half-open interval. The default value is None.\n inclusive : (bool, bool), optional\n A tuple consisting of the (lower flag, upper flag). These flags\n determine whether values exactly equal to the lower or upper limits\n are included. The default value is (True, True).\n\n Returns\n -------\n tvar : float\n Trimmed variance.\n\n Notes\n -----\n `tvar` computes the unbiased sample variance, i.e. it uses a correction\n factor ``n / (n - 1)``.\n\n \"\"\"\n a = asarray(a)\n a = a.astype(float).ravel()\n if limits is None:\n n = len(a)\n return a.var() * n/(n-1.)\n am = mask_to_limits(a, limits, inclusive)\n return masked_var(am)\n\n\ndef tmin(a, lowerlimit=None, axis=0, inclusive=True):\n \"\"\"\n Compute the trimmed minimum\n\n This function finds the miminum value of an array `a` along the\n specified axis, but only considering values greater than a specified\n lower limit.\n\n Parameters\n ----------\n a : array_like\n array of values\n lowerlimit : None or float, optional\n Values in the input array less than the given limit will be ignored.\n When lowerlimit is None, then all values are used. The default value\n is None.\n axis : None or int, optional\n Operate along this axis. None means to use the flattened array and\n the default is zero\n inclusive : {True, False}, optional\n This flag determines whether values exactly equal to the lower limit\n are included. The default value is True.\n\n Returns\n -------\n tmin : float\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n am = mask_to_limits(a, (lowerlimit, None), (inclusive, False))\n return ma.minimum.reduce(am, axis)\n\n\ndef tmax(a, upperlimit=None, axis=0, inclusive=True):\n \"\"\"\n Compute the trimmed maximum\n\n This function computes the maximum value of an array along a given axis,\n while ignoring values larger than a specified upper limit.\n\n Parameters\n ----------\n a : array_like\n array of values\n upperlimit : None or float, optional\n Values in the input array greater than the given limit will be ignored.\n When upperlimit is None, then all values are used. The default value\n is None.\n axis : None or int, optional\n Operate along this axis. None means to use the flattened array and\n the default is zero.\n inclusive : {True, False}, optional\n This flag determines whether values exactly equal to the upper limit\n are included. The default value is True.\n\n Returns\n -------\n tmax : float\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n am = mask_to_limits(a, (None, upperlimit), (False, inclusive))\n return ma.maximum.reduce(am, axis)\n\n\ndef tstd(a, limits=None, inclusive=(True, True)):\n \"\"\"\n Compute the trimmed sample standard deviation\n\n This function finds the sample standard deviation of given values,\n ignoring values outside the given `limits`.\n\n Parameters\n ----------\n a : array_like\n array of values\n limits : None or (lower limit, upper limit), optional\n Values in the input array less than the lower limit or greater than the\n upper limit will be ignored. When limits is None, then all values are\n used. Either of the limit values in the tuple can also be None\n representing a half-open interval. The default value is None.\n inclusive : (bool, bool), optional\n A tuple consisting of the (lower flag, upper flag). These flags\n determine whether values exactly equal to the lower or upper limits\n are included. The default value is (True, True).\n\n Returns\n -------\n tstd : float\n\n Notes\n -----\n `tstd` computes the unbiased sample standard deviation, i.e. it uses a\n correction factor ``n / (n - 1)``.\n\n \"\"\"\n return np.sqrt(tvar(a, limits, inclusive))\n\n\ndef tsem(a, limits=None, inclusive=(True, True)):\n \"\"\"\n Compute the trimmed standard error of the mean.\n\n This function finds the standard error of the mean for given\n values, ignoring values outside the given `limits`.\n\n Parameters\n ----------\n a : array_like\n array of values\n limits : None or (lower limit, upper limit), optional\n Values in the input array less than the lower limit or greater than the\n upper limit will be ignored. When limits is None, then all values are\n used. Either of the limit values in the tuple can also be None\n representing a half-open interval. The default value is None.\n inclusive : (bool, bool), optional\n A tuple consisting of the (lower flag, upper flag). These flags\n determine whether values exactly equal to the lower or upper limits\n are included. The default value is (True, True).\n\n Returns\n -------\n tsem : float\n\n Notes\n -----\n `tsem` uses unbiased sample standard deviation, i.e. it uses a\n correction factor ``n / (n - 1)``.\n\n \"\"\"\n a = np.asarray(a).ravel()\n if limits is None:\n return a.std(ddof=1) / np.sqrt(a.size)\n\n am = mask_to_limits(a, limits, inclusive)\n sd = np.sqrt(masked_var(am))\n return sd / np.sqrt(am.count())\n\n\n#####################################\n############ MOMENTS #############\n#####################################\n\ndef moment(a, moment=1, axis=0):\n \"\"\"\n Calculates the nth moment about the mean for a sample.\n\n Generally used to calculate coefficients of skewness and\n kurtosis.\n\n Parameters\n ----------\n a : array_like\n data\n moment : int\n order of central moment that is returned\n axis : int or None\n Axis along which the central moment is computed. If None, then the data\n array is raveled. The default axis is zero.\n\n Returns\n -------\n n-th central moment : ndarray or float\n The appropriate moment along the given axis or over all values if axis\n is None. The denominator for the moment calculation is the number of\n observations, no degrees of freedom correction is done.\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n if moment == 1:\n # By definition the first moment about the mean is 0.\n shape = list(a.shape)\n del shape[axis]\n if shape:\n # return an actual array of the appropriate shape\n return np.zeros(shape, dtype=float)\n else:\n # the input was 1D, so return a scalar instead of a rank-0 array\n return np.float64(0.0)\n else:\n mn = np.expand_dims(np.mean(a, axis), axis)\n s = np.power((a - mn), moment)\n return np.mean(s, axis)\n\n\ndef variation(a, axis=0):\n \"\"\"\n Computes the coefficient of variation, the ratio of the biased standard\n deviation to the mean.\n\n Parameters\n ----------\n a : array_like\n Input array.\n axis : int or None\n Axis along which to calculate the coefficient of variation.\n\n References\n ----------\n .. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard\n Probability and Statistics Tables and Formulae. Chapman & Hall: New\n York. 2000.\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n return a.std(axis) / a.mean(axis)\n\n\ndef skew(a, axis=0, bias=True):\n \"\"\"\n Computes the skewness of a data set.\n\n For normally distributed data, the skewness should be about 0. A skewness\n value > 0 means that there is more weight in the left tail of the\n distribution. The function `skewtest` can be used to determine if the\n skewness value is close enough to 0, statistically speaking.\n\n Parameters\n ----------\n a : ndarray\n data\n axis : int or None\n axis along which skewness is calculated\n bias : bool\n If False, then the calculations are corrected for statistical bias.\n\n Returns\n -------\n skewness : ndarray\n The skewness of values along an axis, returning 0 where all values are\n equal.\n\n References\n ----------\n\n .. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard\n Probability and Statistics Tables and Formulae. Chapman & Hall: New\n York. 2000.\n Section 2.2.24.1\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n n = a.shape[axis]\n m2 = moment(a, 2, axis)\n m3 = moment(a, 3, axis)\n zero = (m2 == 0)\n vals = np.where(zero, 0, m3 / m2**1.5)\n if not bias:\n can_correct = (n > 2) & (m2 > 0)\n if can_correct.any():\n m2 = np.extract(can_correct, m2)\n m3 = np.extract(can_correct, m3)\n nval = np.sqrt((n-1.0)*n) / (n-2.0) * m3/m2**1.5\n np.place(vals, can_correct, nval)\n\n if vals.ndim == 0:\n return vals.item()\n\n return vals\n\n\ndef kurtosis(a, axis=0, fisher=True, bias=True):\n \"\"\"\n Computes the kurtosis (Fisher or Pearson) of a dataset.\n\n Kurtosis is the fourth central moment divided by the square of the\n variance. If Fisher's definition is used, then 3.0 is subtracted from\n the result to give 0.0 for a normal distribution.\n\n If bias is False then the kurtosis is calculated using k statistics to\n eliminate bias coming from biased moment estimators\n\n Use `kurtosistest` to see if result is close enough to normal.\n\n Parameters\n ----------\n a : array\n data for which the kurtosis is calculated\n axis : int or None\n Axis along which the kurtosis is calculated\n fisher : bool\n If True, Fisher's definition is used (normal ==> 0.0). If False,\n Pearson's definition is used (normal ==> 3.0).\n bias : bool\n If False, then the calculations are corrected for statistical bias.\n\n Returns\n -------\n kurtosis : array\n The kurtosis of values along an axis. If all values are equal,\n return -3 for Fisher's definition and 0 for Pearson's definition.\n\n References\n ----------\n .. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard\n Probability and Statistics Tables and Formulae. Chapman & Hall: New\n York. 2000.\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n n = a.shape[axis]\n m2 = moment(a, 2, axis)\n m4 = moment(a, 4, axis)\n zero = (m2 == 0)\n olderr = np.seterr(all='ignore')\n try:\n vals = np.where(zero, 0, m4 / m2**2.0)\n finally:\n np.seterr(**olderr)\n\n if not bias:\n can_correct = (n > 3) & (m2 > 0)\n if can_correct.any():\n m2 = np.extract(can_correct, m2)\n m4 = np.extract(can_correct, m4)\n nval = 1.0/(n-2)/(n-3) * ((n**2-1.0)*m4/m2**2.0 - 3*(n-1)**2.0)\n np.place(vals, can_correct, nval + 3.0)\n\n if vals.ndim == 0:\n vals = vals.item() # array scalar\n\n if fisher:\n return vals - 3\n else:\n return vals\n\n\n_DescribeResult = namedtuple('DescribeResult', ('nobs', 'minmax', 'mean',\n 'variance', 'skewness',\n 'kurtosis'))\n\n\ndef describe(a, axis=0, ddof=1):\n \"\"\"\n Computes several descriptive statistics of the passed array.\n\n Parameters\n ----------\n a : array_like\n Input data.\n axis : int, optional\n Axis along which statistics are calculated. If axis is None, then data\n array is raveled. The default axis is zero.\n ddof : int, optional\n Delta degrees of freedom. Default is 1.\n\n Returns\n -------\n nobs : int\n Number of observations (length of data along `axis`).\n minmax: tuple of ndarrays or floats\n Minimum and maximum value of data array.\n mean : ndarray or float\n Arithmetic mean of data along axis.\n variance : ndarray or float\n Unbiased variance of the data along axis, denominator is number of\n observations minus one.\n skewness : ndarray or float\n Biased skewness, based on moment calculations with denominator equal to\n the number of observations, i.e. no degrees of freedom correction.\n kurtosis : ndarray or float\n Biased kurtosis (Fisher). The kurtosis is normalized so that it is\n zero for the normal distribution. No degrees of freedom or bias\n correction is used.\n\n See Also\n --------\n skew, kurtosis\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n n = a.shape[axis]\n mm = (np.min(a, axis=axis), np.max(a, axis=axis))\n m = np.mean(a, axis=axis)\n v = np.var(a, axis=axis, ddof=ddof)\n sk = skew(a, axis)\n kurt = kurtosis(a, axis)\n\n # Return namedtuple for clarity\n return _DescribeResult(n, mm, m, v, sk, kurt)\n\n#####################################\n######## NORMALITY TESTS ##########\n#####################################\n\n\ndef skewtest(a, axis=0):\n \"\"\"\n Tests whether the skew is different from the normal distribution.\n\n This function tests the null hypothesis that the skewness of\n the population that the sample was drawn from is the same\n as that of a corresponding normal distribution.\n\n Parameters\n ----------\n a : array\n axis : int or None\n\n Returns\n -------\n z-score : float\n The computed z-score for this test.\n p-value : float\n a 2-sided p-value for the hypothesis test\n\n Notes\n -----\n The sample size must be at least 8.\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n if axis is None:\n a = np.ravel(a)\n axis = 0\n b2 = skew(a, axis)\n n = float(a.shape[axis])\n if n < 8:\n raise ValueError(\n \"skewtest is not valid with less than 8 samples; %i samples\"\n \" were given.\" % int(n))\n y = b2 * math.sqrt(((n + 1) * (n + 3)) / (6.0 * (n - 2)))\n beta2 = (3.0 * (n**2 + 27*n - 70) * (n+1) * (n+3) /\n ((n-2.0) * (n+5) * (n+7) * (n+9)))\n W2 = -1 + math.sqrt(2 * (beta2 - 1))\n delta = 1 / math.sqrt(0.5 * math.log(W2))\n alpha = math.sqrt(2.0 / (W2 - 1))\n y = np.where(y == 0, 1, y)\n Z = delta * np.log(y / alpha + np.sqrt((y / alpha)**2 + 1))\n return Z, 2 * distributions.norm.sf(np.abs(Z))\n\n\ndef kurtosistest(a, axis=0):\n \"\"\"\n Tests whether a dataset has normal kurtosis\n\n This function tests the null hypothesis that the kurtosis\n of the population from which the sample was drawn is that\n of the normal distribution: ``kurtosis = 3(n-1)/(n+1)``.\n\n Parameters\n ----------\n a : array\n array of the sample data\n axis : int or None\n the axis to operate along, or None to work on the whole array.\n The default is the first axis.\n\n Returns\n -------\n z-score : float\n The computed z-score for this test.\n p-value : float\n The 2-sided p-value for the hypothesis test\n\n Notes\n -----\n Valid only for n>20. The Z-score is set to 0 for bad entries.\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n n = float(a.shape[axis])\n if n < 5:\n raise ValueError(\n \"kurtosistest requires at least 5 observations; %i observations\"\n \" were given.\" % int(n))\n if n < 20:\n warnings.warn(\"kurtosistest only valid for n>=20 ... continuing \"\n \"anyway, n=%i\" % int(n))\n b2 = kurtosis(a, axis, fisher=False)\n\n E = 3.0*(n-1) / (n+1)\n varb2 = 24.0*n*(n-2)*(n-3) / ((n+1)*(n+1.)*(n+3)*(n+5))\n x = (b2-E) / np.sqrt(varb2)\n sqrtbeta1 = 6.0*(n*n-5*n+2)/((n+7)*(n+9)) * np.sqrt((6.0*(n+3)*(n+5)) /\n (n*(n-2)*(n-3)))\n A = 6.0 + 8.0/sqrtbeta1 * (2.0/sqrtbeta1 + np.sqrt(1+4.0/(sqrtbeta1**2)))\n term1 = 1 - 2/(9.0*A)\n denom = 1 + x*np.sqrt(2/(A-4.0))\n denom = np.where(denom < 0, 99, denom)\n term2 = np.where(denom < 0, term1, np.power((1-2.0/A)/denom, 1/3.0))\n Z = (term1 - term2) / np.sqrt(2/(9.0*A))\n Z = np.where(denom == 99, 0, Z)\n if Z.ndim == 0:\n Z = Z[()]\n\n # zprob uses upper tail, so Z needs to be positive\n return Z, 2 * distributions.norm.sf(np.abs(Z))\n\n\ndef normaltest(a, axis=0):\n \"\"\"\n Tests whether a sample differs from a normal distribution.\n\n This function tests the null hypothesis that a sample comes\n from a normal distribution. It is based on D'Agostino and\n Pearson's [1]_, [2]_ test that combines skew and kurtosis to\n produce an omnibus test of normality.\n\n\n Parameters\n ----------\n a : array_like\n The array containing the data to be tested.\n axis : int or None\n If None, the array is treated as a single data set, regardless of\n its shape. Otherwise, each 1-d array along axis `axis` is tested.\n\n Returns\n -------\n k2 : float or array\n `s^2 + k^2`, where `s` is the z-score returned by `skewtest` and\n `k` is the z-score returned by `kurtosistest`.\n p-value : float or array\n A 2-sided chi squared probability for the hypothesis test.\n\n References\n ----------\n .. [1] D'Agostino, R. B. (1971), \"An omnibus test of normality for\n moderate and large sample size,\" Biometrika, 58, 341-348\n\n .. [2] D'Agostino, R. and Pearson, E. S. (1973), \"Testing for\n departures from normality,\" Biometrika, 60, 613-622\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n s, _ = skewtest(a, axis)\n k, _ = kurtosistest(a, axis)\n k2 = s*s + k*k\n return k2, chisqprob(k2, 2)\n\n\ndef jarque_bera(x):\n \"\"\"\n Perform the Jarque-Bera goodness of fit test on sample data.\n\n The Jarque-Bera test tests whether the sample data has the skewness and\n kurtosis matching a normal distribution.\n\n Note that this test only works for a large enough number of data samples\n (>2000) as the test statistic asymptotically has a Chi-squared distribution\n with 2 degrees of freedom.\n\n Parameters\n ----------\n x : array_like\n Observations of a random variable.\n\n Returns\n -------\n jb_value : float\n The test statistic.\n p : float\n The p-value for the hypothesis test.\n\n References\n ----------\n .. [1] Jarque, C. and Bera, A. (1980) \"Efficient tests for normality,\n homoscedasticity and serial independence of regression residuals\",\n 6 Econometric Letters 255-259.\n\n Examples\n --------\n >>> from scipy import stats\n >>> np.random.seed(987654321)\n >>> x = np.random.normal(0, 1, 100000)\n >>> y = np.random.rayleigh(1, 100000)\n >>> stats.jarque_bera(x)\n (4.7165707989581342, 0.09458225503041906)\n >>> stats.jarque_bera(y)\n (6713.7098548143422, 0.0)\n\n \"\"\"\n x = np.asarray(x)\n n = float(x.size)\n if n == 0:\n raise ValueError('At least one observation is required.')\n\n mu = x.mean()\n diffx = x - mu\n skewness = (1 / n * np.sum(diffx**3)) / (1 / n * np.sum(diffx**2))**(3 / 2.)\n kurtosis = (1 / n * np.sum(diffx**4)) / (1 / n * np.sum(diffx**2))**2\n jb_value = n / 6 * (skewness**2 + (kurtosis - 3)**2 / 4)\n p = 1 - distributions.chi2.cdf(jb_value, 2)\n\n return jb_value, p\n\n\n#####################################\n###### FREQUENCY FUNCTIONS #######\n#####################################\n\ndef itemfreq(a):\n \"\"\"\n Returns a 2-D array of item frequencies.\n\n Parameters\n ----------\n a : (N,) array_like\n Input array.\n\n Returns\n -------\n itemfreq : (K, 2) ndarray\n A 2-D frequency table. Column 1 contains sorted, unique values from\n `a`, column 2 contains their respective counts.\n\n Examples\n --------\n >>> from scipy import stats\n >>> a = np.array([1, 1, 5, 0, 1, 2, 2, 0, 1, 4])\n >>> stats.itemfreq(a)\n array([[ 0., 2.],\n [ 1., 4.],\n [ 2., 2.],\n [ 4., 1.],\n [ 5., 1.]])\n >>> np.bincount(a)\n array([2, 4, 2, 0, 1, 1])\n\n >>> stats.itemfreq(a/10.)\n array([[ 0. , 2. ],\n [ 0.1, 4. ],\n [ 0.2, 2. ],\n [ 0.4, 1. ],\n [ 0.5, 1. ]])\n\n \"\"\"\n items, inv = np.unique(a, return_inverse=True)\n freq = np.bincount(inv)\n return np.array([items, freq]).T\n\n\ndef scoreatpercentile(a, per, limit=(), interpolation_method='fraction',\n axis=None):\n \"\"\"\n Calculate the score at a given percentile of the input sequence.\n\n For example, the score at `per=50` is the median. If the desired quantile\n lies between two data points, we interpolate between them, according to\n the value of `interpolation`. If the parameter `limit` is provided, it\n should be a tuple (lower, upper) of two values.\n\n Parameters\n ----------\n a : array_like\n A 1-D array of values from which to extract score.\n per : array_like\n Percentile(s) at which to extract score. Values should be in range\n [0,100].\n limit : tuple, optional\n Tuple of two scalars, the lower and upper limits within which to\n compute the percentile. Values of `a` outside\n this (closed) interval will be ignored.\n interpolation : {'fraction', 'lower', 'higher'}, optional\n This optional parameter specifies the interpolation method to use,\n when the desired quantile lies between two data points `i` and `j`\n\n - fraction: ``i + (j - i) * fraction`` where ``fraction`` is the\n fractional part of the index surrounded by ``i`` and ``j``.\n - lower: ``i``.\n - higher: ``j``.\n\n axis : int, optional\n Axis along which the percentiles are computed. The default (None)\n is to compute the median along a flattened version of the array.\n\n Returns\n -------\n score : float or ndarray\n Score at percentile(s).\n\n See Also\n --------\n percentileofscore, numpy.percentile\n\n Notes\n -----\n This function will become obsolete in the future.\n For Numpy 1.9 and higher, `numpy.percentile` provides all the functionality\n that `scoreatpercentile` provides. And it's significantly faster.\n Therefore it's recommended to use `numpy.percentile` for users that have\n numpy >= 1.9.\n\n Examples\n --------\n >>> from scipy import stats\n >>> a = np.arange(100)\n >>> stats.scoreatpercentile(a, 50)\n 49.5\n\n \"\"\"\n # adapted from NumPy's percentile function. When we require numpy >= 1.8,\n # the implementation of this function can be replaced by np.percentile.\n a = np.asarray(a)\n if a.size == 0:\n # empty array, return nan(s) with shape matching `per`\n if np.isscalar(per):\n return np.nan\n else:\n return np.ones(np.asarray(per).shape, dtype=np.float64) * np.nan\n\n if limit:\n a = a[(limit[0] <= a) & (a <= limit[1])]\n\n sorted = np.sort(a, axis=axis)\n if axis is None:\n axis = 0\n\n return _compute_qth_percentile(sorted, per, interpolation_method, axis)\n\n\n# handle sequence of per's without calling sort multiple times\ndef _compute_qth_percentile(sorted, per, interpolation_method, axis):\n if not np.isscalar(per):\n score = [_compute_qth_percentile(sorted, i, interpolation_method, axis)\n for i in per]\n return np.array(score)\n\n if (per < 0) or (per > 100):\n raise ValueError(\"percentile must be in the range [0, 100]\")\n\n indexer = [slice(None)] * sorted.ndim\n idx = per / 100. * (sorted.shape[axis] - 1)\n\n if int(idx) != idx:\n # round fractional indices according to interpolation method\n if interpolation_method == 'lower':\n idx = int(np.floor(idx))\n elif interpolation_method == 'higher':\n idx = int(np.ceil(idx))\n elif interpolation_method == 'fraction':\n pass # keep idx as fraction and interpolate\n else:\n raise ValueError(\"interpolation_method can only be 'fraction', \"\n \"'lower' or 'higher'\")\n\n i = int(idx)\n if i == idx:\n indexer[axis] = slice(i, i + 1)\n weights = array(1)\n sumval = 1.0\n else:\n indexer[axis] = slice(i, i + 2)\n j = i + 1\n weights = array([(j - idx), (idx - i)], float)\n wshape = [1] * sorted.ndim\n wshape[axis] = 2\n weights.shape = wshape\n sumval = weights.sum()\n\n # Use np.add.reduce (== np.sum but a little faster) to coerce data type\n return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n\n\ndef percentileofscore(a, score, kind='rank'):\n \"\"\"\n The percentile rank of a score relative to a list of scores.\n\n A `percentileofscore` of, for example, 80% means that 80% of the\n scores in `a` are below the given score. In the case of gaps or\n ties, the exact definition depends on the optional keyword, `kind`.\n\n Parameters\n ----------\n a : array_like\n Array of scores to which `score` is compared.\n score : int or float\n Score that is compared to the elements in `a`.\n kind : {'rank', 'weak', 'strict', 'mean'}, optional\n This optional parameter specifies the interpretation of the\n resulting score:\n\n - \"rank\": Average percentage ranking of score. In case of\n multiple matches, average the percentage rankings of\n all matching scores.\n - \"weak\": This kind corresponds to the definition of a cumulative\n distribution function. A percentileofscore of 80%\n means that 80% of values are less than or equal\n to the provided score.\n - \"strict\": Similar to \"weak\", except that only values that are\n strictly less than the given score are counted.\n - \"mean\": The average of the \"weak\" and \"strict\" scores, often used in\n testing. See\n\n http://en.wikipedia.org/wiki/Percentile_rank\n\n Returns\n -------\n pcos : float\n Percentile-position of score (0-100) relative to `a`.\n\n See Also\n --------\n numpy.percentile\n\n Examples\n --------\n Three-quarters of the given values lie below a given score:\n\n >>> from scipy import stats\n >>> stats.percentileofscore([1, 2, 3, 4], 3)\n 75.0\n\n With multiple matches, note how the scores of the two matches, 0.6\n and 0.8 respectively, are averaged:\n\n >>> stats.percentileofscore([1, 2, 3, 3, 4], 3)\n 70.0\n\n Only 2/5 values are strictly less than 3:\n\n >>> stats.percentileofscore([1, 2, 3, 3, 4], 3, kind='strict')\n 40.0\n\n But 4/5 values are less than or equal to 3:\n\n >>> stats.percentileofscore([1, 2, 3, 3, 4], 3, kind='weak')\n 80.0\n\n The average between the weak and the strict scores is\n\n >>> stats.percentileofscore([1, 2, 3, 3, 4], 3, kind='mean')\n 60.0\n\n \"\"\"\n a = np.array(a)\n n = len(a)\n\n if kind == 'rank':\n if not np.any(a == score):\n a = np.append(a, score)\n a_len = np.array(list(range(len(a))))\n else:\n a_len = np.array(list(range(len(a)))) + 1.0\n\n a = np.sort(a)\n idx = [a == score]\n pct = (np.mean(a_len[idx]) / n) * 100.0\n return pct\n\n elif kind == 'strict':\n return sum(a < score) / float(n) * 100\n elif kind == 'weak':\n return sum(a <= score) / float(n) * 100\n elif kind == 'mean':\n return (sum(a < score) + sum(a <= score)) * 50 / float(n)\n else:\n raise ValueError(\"kind can only be 'rank', 'strict', 'weak' or 'mean'\")\n\n\ndef histogram2(a, bins):\n \"\"\"\n Compute histogram using divisions in bins.\n\n Count the number of times values from array `a` fall into\n numerical ranges defined by `bins`. Range x is given by\n bins[x] <= range_x < bins[x+1] where x =0,N and N is the\n length of the `bins` array. The last range is given by\n bins[N] <= range_N < infinity. Values less than bins[0] are\n not included in the histogram.\n\n Parameters\n ----------\n a : array_like of rank 1\n The array of values to be assigned into bins\n bins : array_like of rank 1\n Defines the ranges of values to use during histogramming.\n\n Returns\n -------\n histogram2 : ndarray of rank 1\n Each value represents the occurrences for a given bin (range) of\n values.\n\n \"\"\"\n # comment: probably obsoleted by numpy.histogram()\n n = np.searchsorted(np.sort(a), bins)\n n = np.concatenate([n, [len(a)]])\n return n[1:] - n[:-1]\n\n\ndef histogram(a, numbins=10, defaultlimits=None, weights=None, printextras=False):\n \"\"\"\n Separates the range into several bins and returns the number of instances\n in each bin.\n\n Parameters\n ----------\n a : array_like\n Array of scores which will be put into bins.\n numbins : int, optional\n The number of bins to use for the histogram. Default is 10.\n defaultlimits : tuple (lower, upper), optional\n The lower and upper values for the range of the histogram.\n If no value is given, a range slightly larger than the range of the\n values in a is used. Specifically ``(a.min() - s, a.max() + s)``,\n where ``s = (1/2)(a.max() - a.min()) / (numbins - 1)``.\n weights : array_like, optional\n The weights for each value in `a`. Default is None, which gives each\n value a weight of 1.0\n printextras : bool, optional\n If True, if there are extra points (i.e. the points that fall outside\n the bin limits) a warning is raised saying how many of those points\n there are. Default is False.\n\n Returns\n -------\n histogram : ndarray\n Number of points (or sum of weights) in each bin.\n low_range : float\n Lowest value of histogram, the lower limit of the first bin.\n binsize : float\n The size of the bins (all bins have the same size).\n extrapoints : int\n The number of points outside the range of the histogram.\n\n See Also\n --------\n numpy.histogram\n\n Notes\n -----\n This histogram is based on numpy's histogram but has a larger range by\n default if default limits is not set.\n\n \"\"\"\n a = np.ravel(a)\n if defaultlimits is None:\n # no range given, so use values in `a`\n data_min = a.min()\n data_max = a.max()\n # Have bins extend past min and max values slightly\n s = (data_max - data_min) / (2. * (numbins - 1.))\n defaultlimits = (data_min - s, data_max + s)\n\n # use numpy's histogram method to compute bins\n hist, bin_edges = np.histogram(a, bins=numbins, range=defaultlimits,\n weights=weights)\n # hist are not always floats, convert to keep with old output\n hist = np.array(hist, dtype=float)\n # fixed width for bins is assumed, as numpy's histogram gives\n # fixed width bins for int values for 'bins'\n binsize = bin_edges[1] - bin_edges[0]\n # calculate number of extra points\n extrapoints = len([v for v in a\n if defaultlimits[0] > v or v > defaultlimits[1]])\n if extrapoints > 0 and printextras:\n warnings.warn(\"Points outside given histogram range = %s\"\n % extrapoints)\n\n return hist, defaultlimits[0], binsize, extrapoints\n\n\ndef cumfreq(a, numbins=10, defaultreallimits=None, weights=None):\n \"\"\"\n Returns a cumulative frequency histogram, using the histogram function.\n\n Parameters\n ----------\n a : array_like\n Input array.\n numbins : int, optional\n The number of bins to use for the histogram. Default is 10.\n defaultlimits : tuple (lower, upper), optional\n The lower and upper values for the range of the histogram.\n If no value is given, a range slightly larger than the range of the\n values in `a` is used. Specifically ``(a.min() - s, a.max() + s)``,\n where ``s = (1/2)(a.max() - a.min()) / (numbins - 1)``.\n weights : array_like, optional\n The weights for each value in `a`. Default is None, which gives each\n value a weight of 1.0\n\n Returns\n -------\n cumfreq : ndarray\n Binned values of cumulative frequency.\n lowerreallimit : float\n Lower real limit\n binsize : float\n Width of each bin.\n extrapoints : int\n Extra points.\n\n Examples\n --------\n >>> from scipy import stats\n >>> x = [1, 4, 2, 1, 3, 1]\n >>> cumfreqs, lowlim, binsize, extrapoints = stats.cumfreq(x, numbins=4)\n >>> cumfreqs\n array([ 3., 4., 5., 6.])\n >>> cumfreqs, lowlim, binsize, extrapoints = \\\n ... stats.cumfreq(x, numbins=4, defaultreallimits=(1.5, 5))\n >>> cumfreqs\n array([ 1., 2., 3., 3.])\n >>> extrapoints\n 3\n\n \"\"\"\n h, l, b, e = histogram(a, numbins, defaultreallimits, weights=weights)\n cumhist = np.cumsum(h * 1, axis=0)\n return cumhist, l, b, e\n\n\ndef relfreq(a, numbins=10, defaultreallimits=None, weights=None):\n \"\"\"\n Returns a relative frequency histogram, using the histogram function.\n\n Parameters\n ----------\n a : array_like\n Input array.\n numbins : int, optional\n The number of bins to use for the histogram. Default is 10.\n defaultreallimits : tuple (lower, upper), optional\n The lower and upper values for the range of the histogram.\n If no value is given, a range slightly larger than the range of the\n values in a is used. Specifically ``(a.min() - s, a.max() + s)``,\n where ``s = (1/2)(a.max() - a.min()) / (numbins - 1)``.\n weights : array_like, optional\n The weights for each value in `a`. Default is None, which gives each\n value a weight of 1.0\n\n Returns\n -------\n relfreq : ndarray\n Binned values of relative frequency.\n lowerreallimit : float\n Lower real limit\n binsize : float\n Width of each bin.\n extrapoints : int\n Extra points.\n\n Examples\n --------\n >>> from scipy import stats\n >>> a = np.array([1, 4, 2, 1, 3, 1])\n >>> relfreqs, lowlim, binsize, extrapoints = stats.relfreq(a, numbins=4)\n >>> relfreqs\n array([ 0.5 , 0.16666667, 0.16666667, 0.16666667])\n >>> np.sum(relfreqs) # relative frequencies should add up to 1\n 0.99999999999999989\n\n \"\"\"\n h, l, b, e = histogram(a, numbins, defaultreallimits, weights=weights)\n h = np.array(h / float(np.array(a).shape[0]))\n return h, l, b, e\n\n\n#####################################\n###### VARIABILITY FUNCTIONS #####\n#####################################\n\ndef obrientransform(*args):\n \"\"\"\n Computes the O'Brien transform on input data (any number of arrays).\n\n Used to test for homogeneity of variance prior to running one-way stats.\n Each array in ``*args`` is one level of a factor.\n If `f_oneway` is run on the transformed data and found significant,\n the variances are unequal. From Maxwell and Delaney [1]_, p.112.\n\n Parameters\n ----------\n args : tuple of array_like\n Any number of arrays.\n\n Returns\n -------\n obrientransform : ndarray\n Transformed data for use in an ANOVA. The first dimension\n of the result corresponds to the sequence of transformed\n arrays. If the arrays given are all 1-D of the same length,\n the return value is a 2-D array; otherwise it is a 1-D array\n of type object, with each element being an ndarray.\n\n References\n ----------\n .. [1] S. E. Maxwell and H. D. Delaney, \"Designing Experiments and\n Analyzing Data: A Model Comparison Perspective\", Wadsworth, 1990.\n\n Examples\n --------\n We'll test the following data sets for differences in their variance.\n\n >>> x = [10, 11, 13, 9, 7, 12, 12, 9, 10]\n >>> y = [13, 21, 5, 10, 8, 14, 10, 12, 7, 15]\n\n Apply the O'Brien transform to the data.\n\n >>> tx, ty = obrientransform(x, y)\n\n Use `scipy.stats.f_oneway` to apply a one-way ANOVA test to the\n transformed data.\n\n >>> from scipy.stats import f_oneway\n >>> F, p = f_oneway(tx, ty)\n >>> p\n 0.1314139477040335\n\n If we require that ``p < 0.05`` for significance, we cannot conclude\n that the variances are different.\n \"\"\"\n TINY = np.sqrt(np.finfo(float).eps)\n\n # `arrays` will hold the transformed arguments.\n arrays = []\n\n for arg in args:\n a = np.asarray(arg)\n n = len(a)\n mu = np.mean(a)\n sq = (a - mu)**2\n sumsq = sq.sum()\n\n # The O'Brien transform.\n t = ((n - 1.5) * n * sq - 0.5 * sumsq) / ((n - 1) * (n - 2))\n\n # Check that the mean of the transformed data is equal to the\n # original variance.\n var = sumsq / (n - 1)\n if abs(var - np.mean(t)) > TINY:\n raise ValueError('Lack of convergence in obrientransform.')\n\n arrays.append(t)\n\n # If the arrays are not all the same shape, calling np.array(arrays)\n # creates a 1-D array with dtype `object` in numpy 1.6+. In numpy\n # 1.5.x, it raises an exception. To work around this, we explicitly\n # set the dtype to `object` when the arrays are not all the same shape.\n if len(arrays) < 2 or all(x.shape == arrays[0].shape for x in arrays[1:]):\n dt = None\n else:\n dt = object\n return np.array(arrays, dtype=dt)\n\n\ndef signaltonoise(a, axis=0, ddof=0):\n \"\"\"\n The signal-to-noise ratio of the input data.\n\n Returns the signal-to-noise ratio of `a`, here defined as the mean\n divided by the standard deviation.\n\n Parameters\n ----------\n a : array_like\n An array_like object containing the sample data.\n axis : int or None, optional\n If axis is equal to None, the array is first ravel'd. If axis is an\n integer, this is the axis over which to operate. Default is 0.\n ddof : int, optional\n Degrees of freedom correction for standard deviation. Default is 0.\n\n Returns\n -------\n s2n : ndarray\n The mean to standard deviation ratio(s) along `axis`, or 0 where the\n standard deviation is 0.\n\n \"\"\"\n a = np.asanyarray(a)\n m = a.mean(axis)\n sd = a.std(axis=axis, ddof=ddof)\n return np.where(sd == 0, 0, m/sd)\n\n\ndef sem(a, axis=0, ddof=1):\n \"\"\"\n Calculates the standard error of the mean (or standard error of\n measurement) of the values in the input array.\n\n Parameters\n ----------\n a : array_like\n An array containing the values for which the standard error is\n returned.\n axis : int or None, optional.\n If axis is None, ravel `a` first. If axis is an integer, this will be\n the axis over which to operate. Defaults to 0.\n ddof : int, optional\n Delta degrees-of-freedom. How many degrees of freedom to adjust\n for bias in limited samples relative to the population estimate\n of variance. Defaults to 1.\n\n Returns\n -------\n s : ndarray or float\n The standard error of the mean in the sample(s), along the input axis.\n\n Notes\n -----\n The default value for `ddof` is different to the default (0) used by other\n ddof containing routines, such as np.std nd stats.nanstd.\n\n Examples\n --------\n Find standard error along the first axis:\n\n >>> from scipy import stats\n >>> a = np.arange(20).reshape(5,4)\n >>> stats.sem(a)\n array([ 2.8284, 2.8284, 2.8284, 2.8284])\n\n Find standard error across the whole array, using n degrees of freedom:\n\n >>> stats.sem(a, axis=None, ddof=0)\n 1.2893796958227628\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n n = a.shape[axis]\n s = np.std(a, axis=axis, ddof=ddof) / np.sqrt(n)\n return s\n\n\ndef zscore(a, axis=0, ddof=0):\n \"\"\"\n Calculates the z score of each value in the sample, relative to the sample\n mean and standard deviation.\n\n Parameters\n ----------\n a : array_like\n An array like object containing the sample data.\n axis : int or None, optional\n If `axis` is equal to None, the array is first raveled. If `axis` is\n an integer, this is the axis over which to operate. Default is 0.\n ddof : int, optional\n Degrees of freedom correction in the calculation of the\n standard deviation. Default is 0.\n\n Returns\n -------\n zscore : array_like\n The z-scores, standardized by mean and standard deviation of input\n array `a`.\n\n Notes\n -----\n This function preserves ndarray subclasses, and works also with\n matrices and masked arrays (it uses `asanyarray` instead of `asarray`\n for parameters).\n\n Examples\n --------\n >>> a = np.array([ 0.7972, 0.0767, 0.4383, 0.7866, 0.8091, 0.1954,\n 0.6307, 0.6599, 0.1065, 0.0508])\n >>> from scipy import stats\n >>> stats.zscore(a)\n array([ 1.1273, -1.247 , -0.0552, 1.0923, 1.1664, -0.8559, 0.5786,\n 0.6748, -1.1488, -1.3324])\n\n Computing along a specified axis, using n-1 degrees of freedom (``ddof=1``)\n to calculate the standard deviation:\n\n >>> b = np.array([[ 0.3148, 0.0478, 0.6243, 0.4608],\n [ 0.7149, 0.0775, 0.6072, 0.9656],\n [ 0.6341, 0.1403, 0.9759, 0.4064],\n [ 0.5918, 0.6948, 0.904 , 0.3721],\n [ 0.0921, 0.2481, 0.1188, 0.1366]])\n >>> stats.zscore(b, axis=1, ddof=1)\n array([[-0.19264823, -1.28415119, 1.07259584, 0.40420358],\n [ 0.33048416, -1.37380874, 0.04251374, 1.00081084],\n [ 0.26796377, -1.12598418, 1.23283094, -0.37481053],\n [-0.22095197, 0.24468594, 1.19042819, -1.21416216],\n [-0.82780366, 1.4457416 , -0.43867764, -0.1792603 ]])\n \"\"\"\n a = np.asanyarray(a)\n mns = a.mean(axis=axis)\n sstd = a.std(axis=axis, ddof=ddof)\n if axis and mns.ndim < a.ndim:\n return ((a - np.expand_dims(mns, axis=axis)) /\n np.expand_dims(sstd, axis=axis))\n else:\n return (a - mns) / sstd\n\n\ndef zmap(scores, compare, axis=0, ddof=0):\n \"\"\"\n Calculates the relative z-scores.\n\n Returns an array of z-scores, i.e., scores that are standardized to zero\n mean and unit variance, where mean and variance are calculated from the\n comparison array.\n\n Parameters\n ----------\n scores : array_like\n The input for which z-scores are calculated.\n compare : array_like\n The input from which the mean and standard deviation of the\n normalization are taken; assumed to have the same dimension as\n `scores`.\n axis : int or None, optional\n Axis over which mean and variance of `compare` are calculated.\n Default is 0.\n ddof : int, optional\n Degrees of freedom correction in the calculation of the\n standard deviation. Default is 0.\n\n Returns\n -------\n zscore : array_like\n Z-scores, in the same shape as `scores`.\n\n Notes\n -----\n This function preserves ndarray subclasses, and works also with\n matrices and masked arrays (it uses `asanyarray` instead of `asarray`\n for parameters).\n\n Examples\n --------\n >>> a = [0.5, 2.0, 2.5, 3]\n >>> b = [0, 1, 2, 3, 4]\n >>> zmap(a, b)\n array([-1.06066017, 0. , 0.35355339, 0.70710678])\n \"\"\"\n scores, compare = map(np.asanyarray, [scores, compare])\n mns = compare.mean(axis=axis)\n sstd = compare.std(axis=axis, ddof=ddof)\n if axis and mns.ndim < compare.ndim:\n return ((scores - np.expand_dims(mns, axis=axis)) /\n np.expand_dims(sstd, axis=axis))\n else:\n return (scores - mns) / sstd\n\n\n#####################################\n####### TRIMMING FUNCTIONS #######\n#####################################\n\ndef threshold(a, threshmin=None, threshmax=None, newval=0):\n \"\"\"\n Clip array to a given value.\n\n Similar to numpy.clip(), except that values less than `threshmin` or\n greater than `threshmax` are replaced by `newval`, instead of by\n `threshmin` and `threshmax` respectively.\n\n Parameters\n ----------\n a : array_like\n Data to threshold.\n threshmin : float, int or None, optional\n Minimum threshold, defaults to None.\n threshmax : float, int or None, optional\n Maximum threshold, defaults to None.\n newval : float or int, optional\n Value to put in place of values in `a` outside of bounds.\n Defaults to 0.\n\n Returns\n -------\n out : ndarray\n The clipped input array, with values less than `threshmin` or\n greater than `threshmax` replaced with `newval`.\n\n Examples\n --------\n >>> a = np.array([9, 9, 6, 3, 1, 6, 1, 0, 0, 8])\n >>> from scipy import stats\n >>> stats.threshold(a, threshmin=2, threshmax=8, newval=-1)\n array([-1, -1, 6, 3, -1, 6, -1, -1, -1, 8])\n\n \"\"\"\n a = asarray(a).copy()\n mask = zeros(a.shape, dtype=bool)\n if threshmin is not None:\n mask |= (a < threshmin)\n if threshmax is not None:\n mask |= (a > threshmax)\n a[mask] = newval\n return a\n\n\ndef sigmaclip(a, low=4., high=4.):\n \"\"\"\n Iterative sigma-clipping of array elements.\n\n The output array contains only those elements of the input array `c`\n that satisfy the conditions ::\n\n mean(c) - std(c)*low < c < mean(c) + std(c)*high\n\n Starting from the full sample, all elements outside the critical range are\n removed. The iteration continues with a new critical range until no\n elements are outside the range.\n\n Parameters\n ----------\n a : array_like\n Data array, will be raveled if not 1-D.\n low : float, optional\n Lower bound factor of sigma clipping. Default is 4.\n high : float, optional\n Upper bound factor of sigma clipping. Default is 4.\n\n Returns\n -------\n c : ndarray\n Input array with clipped elements removed.\n critlower : float\n Lower threshold value use for clipping.\n critlupper : float\n Upper threshold value use for clipping.\n\n Examples\n --------\n >>> a = np.concatenate((np.linspace(9.5,10.5,31), np.linspace(0,20,5)))\n >>> fact = 1.5\n >>> c, low, upp = sigmaclip(a, fact, fact)\n >>> c\n array([ 9.96666667, 10. , 10.03333333, 10. ])\n >>> c.var(), c.std()\n (0.00055555555555555165, 0.023570226039551501)\n >>> low, c.mean() - fact*c.std(), c.min()\n (9.9646446609406727, 9.9646446609406727, 9.9666666666666668)\n >>> upp, c.mean() + fact*c.std(), c.max()\n (10.035355339059327, 10.035355339059327, 10.033333333333333)\n\n >>> a = np.concatenate((np.linspace(9.5,10.5,11),\n np.linspace(-100,-50,3)))\n >>> c, low, upp = sigmaclip(a, 1.8, 1.8)\n >>> (c == np.linspace(9.5,10.5,11)).all()\n True\n\n \"\"\"\n c = np.asarray(a).ravel()\n delta = 1\n while delta:\n c_std = c.std()\n c_mean = c.mean()\n size = c.size\n critlower = c_mean - c_std*low\n critupper = c_mean + c_std*high\n c = c[(c > critlower) & (c < critupper)]\n delta = size - c.size\n return c, critlower, critupper\n\n\ndef trimboth(a, proportiontocut, axis=0):\n \"\"\"\n Slices off a proportion of items from both ends of an array.\n\n Slices off the passed proportion of items from both ends of the passed\n array (i.e., with `proportiontocut` = 0.1, slices leftmost 10% **and**\n rightmost 10% of scores). You must pre-sort the array if you want\n 'proper' trimming. Slices off less if proportion results in a\n non-integer slice index (i.e., conservatively slices off\n `proportiontocut`).\n\n Parameters\n ----------\n a : array_like\n Data to trim.\n proportiontocut : float\n Proportion (in range 0-1) of total data set to trim of each end.\n axis : int or None, optional\n Axis along which the observations are trimmed. The default is to trim\n along axis=0. If axis is None then the array will be flattened before\n trimming.\n\n Returns\n -------\n out : ndarray\n Trimmed version of array `a`.\n\n See Also\n --------\n trim_mean\n\n Examples\n --------\n >>> from scipy import stats\n >>> a = np.arange(20)\n >>> b = stats.trimboth(a, 0.1)\n >>> b.shape\n (16,)\n\n \"\"\"\n a = np.asarray(a)\n if axis is None:\n a = a.ravel()\n axis = 0\n\n nobs = a.shape[axis]\n lowercut = int(proportiontocut * nobs)\n uppercut = nobs - lowercut\n if (lowercut >= uppercut):\n raise ValueError(\"Proportion too big.\")\n\n sl = [slice(None)] * a.ndim\n sl[axis] = slice(lowercut, uppercut)\n return a[sl]\n\n\ndef trim1(a, proportiontocut, tail='right'):\n \"\"\"\n Slices off a proportion of items from ONE end of the passed array\n distribution.\n\n If `proportiontocut` = 0.1, slices off 'leftmost' or 'rightmost'\n 10% of scores. Slices off LESS if proportion results in a non-integer\n slice index (i.e., conservatively slices off `proportiontocut` ).\n\n Parameters\n ----------\n a : array_like\n Input array\n proportiontocut : float\n Fraction to cut off of 'left' or 'right' of distribution\n tail : {'left', 'right'}, optional\n Defaults to 'right'.\n\n Returns\n -------\n trim1 : ndarray\n Trimmed version of array `a`\n\n \"\"\"\n a = asarray(a)\n if tail.lower() == 'right':\n lowercut = 0\n uppercut = len(a) - int(proportiontocut * len(a))\n elif tail.lower() == 'left':\n lowercut = int(proportiontocut * len(a))\n uppercut = len(a)\n\n return a[lowercut:uppercut]\n\n\ndef trim_mean(a, proportiontocut, axis=0):\n \"\"\"\n Return mean of array after trimming distribution from both lower and upper\n tails.\n\n If `proportiontocut` = 0.1, slices off 'leftmost' and 'rightmost' 10% of\n scores. Slices off LESS if proportion results in a non-integer slice\n index (i.e., conservatively slices off `proportiontocut` ).\n\n Parameters\n ----------\n a : array_like\n Input array\n proportiontocut : float\n Fraction to cut off of both tails of the distribution\n axis : int or None, optional\n Axis along which the trimmed means are computed. The default is axis=0.\n If axis is None then the trimmed mean will be computed for the\n flattened array.\n\n Returns\n -------\n trim_mean : ndarray\n Mean of trimmed array.\n\n See Also\n --------\n trimboth\n\n Examples\n --------\n >>> from scipy import stats\n >>> x = np.arange(20)\n >>> stats.trim_mean(x, 0.1)\n 9.5\n >>> x2 = x.reshape(5, 4)\n >>> x2\n array([[ 0, 1, 2, 3],\n [ 4, 5, 6, 7],\n [ 8, 9, 10, 11],\n [12, 13, 14, 15],\n [16, 17, 18, 19]])\n >>> stats.trim_mean(x2, 0.25)\n array([ 8., 9., 10., 11.])\n >>> stats.trim_mean(x2, 0.25, axis=1)\n array([ 1.5, 5.5, 9.5, 13.5, 17.5])\n\n \"\"\"\n a = np.asarray(a)\n if axis is None:\n nobs = a.size\n else:\n nobs = a.shape[axis]\n lowercut = int(proportiontocut * nobs)\n uppercut = nobs - lowercut - 1\n if (lowercut > uppercut):\n raise ValueError(\"Proportion too big.\")\n\n try:\n atmp = np.partition(a, (lowercut, uppercut), axis)\n except AttributeError:\n atmp = np.sort(a, axis)\n\n newa = trimboth(atmp, proportiontocut, axis=axis)\n return np.mean(newa, axis=axis)\n\n\ndef f_oneway(*args):\n \"\"\"\n Performs a 1-way ANOVA.\n\n The one-way ANOVA tests the null hypothesis that two or more groups have\n the same population mean. The test is applied to samples from two or\n more groups, possibly with differing sizes.\n\n Parameters\n ----------\n sample1, sample2, ... : array_like\n The sample measurements for each group.\n\n Returns\n -------\n F-value : float\n The computed F-value of the test.\n p-value : float\n The associated p-value from the F-distribution.\n\n Notes\n -----\n The ANOVA test has important assumptions that must be satisfied in order\n for the associated p-value to be valid.\n\n 1. The samples are independent.\n 2. Each sample is from a normally distributed population.\n 3. The population standard deviations of the groups are all equal. This\n property is known as homoscedasticity.\n\n If these assumptions are not true for a given set of data, it may still be\n possible to use the Kruskal-Wallis H-test (`scipy.stats.kruskal`) although\n with some loss of power.\n\n The algorithm is from Heiman[2], pp.394-7.\n\n\n References\n ----------\n .. [1] Lowry, Richard. \"Concepts and Applications of Inferential\n Statistics\". Chapter 14.\n http://faculty.vassar.edu/lowry/ch14pt1.html\n\n .. [2] Heiman, G.W. Research Methods in Statistics. 2002.\n\n \"\"\"\n args = [np.asarray(arg, dtype=float) for arg in args]\n na = len(args) # ANOVA on 'na' groups, each in it's own array\n alldata = np.concatenate(args)\n bign = len(alldata)\n sstot = ss(alldata) - (square_of_sums(alldata) / float(bign))\n ssbn = 0\n for a in args:\n ssbn += square_of_sums(a) / float(len(a))\n\n ssbn -= (square_of_sums(alldata) / float(bign))\n sswn = sstot - ssbn\n dfbn = na - 1\n dfwn = bign - na\n msb = ssbn / float(dfbn)\n msw = sswn / float(dfwn)\n f = msb / msw\n prob = special.fdtrc(dfbn, dfwn, f) # equivalent to stats.f.sf\n return f, prob\n\n\ndef pearsonr(x, y):\n \"\"\"\n Calculates a Pearson correlation coefficient and the p-value for testing\n non-correlation.\n\n The Pearson correlation coefficient measures the linear relationship\n between two datasets. Strictly speaking, Pearson's correlation requires\n that each dataset be normally distributed. Like other correlation\n coefficients, this one varies between -1 and +1 with 0 implying no\n correlation. Correlations of -1 or +1 imply an exact linear\n relationship. Positive correlations imply that as x increases, so does\n y. Negative correlations imply that as x increases, y decreases.\n\n The p-value roughly indicates the probability of an uncorrelated system\n producing datasets that have a Pearson correlation at least as extreme\n as the one computed from these datasets. The p-values are not entirely\n reliable but are probably reasonable for datasets larger than 500 or so.\n\n Parameters\n ----------\n x : (N,) array_like\n Input\n y : (N,) array_like\n Input\n\n Returns\n -------\n (Pearson's correlation coefficient,\n 2-tailed p-value)\n\n References\n ----------\n http://www.statsoft.com/textbook/glosp.html#Pearson%20Correlation\n\n \"\"\"\n # x and y should have same length.\n x = np.asarray(x)\n y = np.asarray(y)\n n = len(x)\n mx = x.mean()\n my = y.mean()\n xm, ym = x - mx, y - my\n r_num = np.add.reduce(xm * ym)\n r_den = np.sqrt(ss(xm) * ss(ym))\n r = r_num / r_den\n\n # Presumably, if abs(r) > 1, then it is only some small artifact of floating\n # point arithmetic.\n r = max(min(r, 1.0), -1.0)\n df = n - 2\n if abs(r) == 1.0:\n prob = 0.0\n else:\n t_squared = r**2 * (df / ((1.0 - r) * (1.0 + r)))\n prob = betai(0.5*df, 0.5, df/(df+t_squared))\n\n return r, prob\n\n\ndef fisher_exact(table, alternative='two-sided'):\n \"\"\"Performs a Fisher exact test on a 2x2 contingency table.\n\n Parameters\n ----------\n table : array_like of ints\n A 2x2 contingency table. Elements should be non-negative integers.\n alternative : {'two-sided', 'less', 'greater'}, optional\n Which alternative hypothesis to the null hypothesis the test uses.\n Default is 'two-sided'.\n\n Returns\n -------\n oddsratio : float\n This is prior odds ratio and not a posterior estimate.\n p_value : float\n P-value, the probability of obtaining a distribution at least as\n extreme as the one that was actually observed, assuming that the\n null hypothesis is true.\n\n See Also\n --------\n chi2_contingency : Chi-square test of independence of variables in a\n contingency table.\n\n Notes\n -----\n The calculated odds ratio is different from the one R uses. In R language,\n this implementation returns the (more common) \"unconditional Maximum\n Likelihood Estimate\", while R uses the \"conditional Maximum Likelihood\n Estimate\".\n\n For tables with large numbers the (inexact) chi-square test implemented\n in the function `chi2_contingency` can also be used.\n\n Examples\n --------\n Say we spend a few days counting whales and sharks in the Atlantic and\n Indian oceans. In the Atlantic ocean we find 8 whales and 1 shark, in the\n Indian ocean 2 whales and 5 sharks. Then our contingency table is::\n\n Atlantic Indian\n whales 8 2\n sharks 1 5\n\n We use this table to find the p-value:\n\n >>> oddsratio, pvalue = stats.fisher_exact([[8, 2], [1, 5]])\n >>> pvalue\n 0.0349...\n\n The probability that we would observe this or an even more imbalanced ratio\n by chance is about 3.5%. A commonly used significance level is 5%, if we\n adopt that we can therefore conclude that our observed imbalance is\n statistically significant; whales prefer the Atlantic while sharks prefer\n the Indian ocean.\n\n \"\"\"\n hypergeom = distributions.hypergeom\n c = np.asarray(table, dtype=np.int64) # int32 is not enough for the algorithm\n if not c.shape == (2, 2):\n raise ValueError(\"The input `table` must be of shape (2, 2).\")\n\n if np.any(c < 0):\n raise ValueError(\"All values in `table` must be nonnegative.\")\n\n if 0 in c.sum(axis=0) or 0 in c.sum(axis=1):\n # If both values in a row or column are zero, the p-value is 1 and\n # the odds ratio is NaN.\n return np.nan, 1.0\n\n if c[1,0] > 0 and c[0,1] > 0:\n oddsratio = c[0,0] * c[1,1] / float(c[1,0] * c[0,1])\n else:\n oddsratio = np.inf\n\n n1 = c[0,0] + c[0,1]\n n2 = c[1,0] + c[1,1]\n n = c[0,0] + c[1,0]\n\n def binary_search(n, n1, n2, side):\n \"\"\"Binary search for where to begin lower/upper halves in two-sided\n test.\n \"\"\"\n if side == \"upper\":\n minval = mode\n maxval = n\n else:\n minval = 0\n maxval = mode\n guess = -1\n while maxval - minval > 1:\n if maxval == minval + 1 and guess == minval:\n guess = maxval\n else:\n guess = (maxval + minval) // 2\n pguess = hypergeom.pmf(guess, n1 + n2, n1, n)\n if side == \"upper\":\n ng = guess - 1\n else:\n ng = guess + 1\n if pguess <= pexact < hypergeom.pmf(ng, n1 + n2, n1, n):\n break\n elif pguess < pexact:\n maxval = guess\n else:\n minval = guess\n if guess == -1:\n guess = minval\n if side == \"upper\":\n while guess > 0 and hypergeom.pmf(guess, n1 + n2, n1, n) < pexact * epsilon:\n guess -= 1\n while hypergeom.pmf(guess, n1 + n2, n1, n) > pexact / epsilon:\n guess += 1\n else:\n while hypergeom.pmf(guess, n1 + n2, n1, n) < pexact * epsilon:\n guess += 1\n while guess > 0 and hypergeom.pmf(guess, n1 + n2, n1, n) > pexact / epsilon:\n guess -= 1\n return guess\n\n if alternative == 'less':\n pvalue = hypergeom.cdf(c[0,0], n1 + n2, n1, n)\n elif alternative == 'greater':\n # Same formula as the 'less' case, but with the second column.\n pvalue = hypergeom.cdf(c[0,1], n1 + n2, n1, c[0,1] + c[1,1])\n elif alternative == 'two-sided':\n mode = int(float((n + 1) * (n1 + 1)) / (n1 + n2 + 2))\n pexact = hypergeom.pmf(c[0,0], n1 + n2, n1, n)\n pmode = hypergeom.pmf(mode, n1 + n2, n1, n)\n\n epsilon = 1 - 1e-4\n if np.abs(pexact - pmode) / np.maximum(pexact, pmode) <= 1 - epsilon:\n return oddsratio, 1.\n\n elif c[0,0] < mode:\n plower = hypergeom.cdf(c[0,0], n1 + n2, n1, n)\n if hypergeom.pmf(n, n1 + n2, n1, n) > pexact / epsilon:\n return oddsratio, plower\n\n guess = binary_search(n, n1, n2, \"upper\")\n pvalue = plower + hypergeom.sf(guess - 1, n1 + n2, n1, n)\n else:\n pupper = hypergeom.sf(c[0,0] - 1, n1 + n2, n1, n)\n if hypergeom.pmf(0, n1 + n2, n1, n) > pexact / epsilon:\n return oddsratio, pupper\n\n guess = binary_search(n, n1, n2, \"lower\")\n pvalue = pupper + hypergeom.cdf(guess, n1 + n2, n1, n)\n else:\n msg = \"`alternative` should be one of {'two-sided', 'less', 'greater'}\"\n raise ValueError(msg)\n\n if pvalue > 1.0:\n pvalue = 1.0\n\n return oddsratio, pvalue\n\n\ndef spearmanr(a, b=None, axis=0):\n \"\"\"\n Calculates a Spearman rank-order correlation coefficient and the p-value\n to test for non-correlation.\n\n The Spearman correlation is a nonparametric measure of the monotonicity\n of the relationship between two datasets. Unlike the Pearson correlation,\n the Spearman correlation does not assume that both datasets are normally\n distributed. Like other correlation coefficients, this one varies\n between -1 and +1 with 0 implying no correlation. Correlations of -1 or\n +1 imply an exact monotonic relationship. Positive correlations imply that\n as x increases, so does y. Negative correlations imply that as x\n increases, y decreases.\n\n The p-value roughly indicates the probability of an uncorrelated system\n producing datasets that have a Spearman correlation at least as extreme\n as the one computed from these datasets. The p-values are not entirely\n reliable but are probably reasonable for datasets larger than 500 or so.\n\n Parameters\n ----------\n a, b : 1D or 2D array_like, b is optional\n One or two 1-D or 2-D arrays containing multiple variables and\n observations. Each column of `a` and `b` represents a variable, and\n each row entry a single observation of those variables. See also\n `axis`. Both arrays need to have the same length in the `axis`\n dimension.\n axis : int or None, optional\n If axis=0 (default), then each column represents a variable, with\n observations in the rows. If axis=0, the relationship is transposed:\n each row represents a variable, while the columns contain observations.\n If axis=None, then both arrays will be raveled.\n\n Returns\n -------\n rho : float or ndarray (2-D square)\n Spearman correlation matrix or correlation coefficient (if only 2\n variables are given as parameters. Correlation matrix is square with\n length equal to total number of variables (columns or rows) in a and b\n combined.\n p-value : float\n The two-sided p-value for a hypothesis test whose null hypothesis is\n that two sets of data are uncorrelated, has same dimension as rho.\n\n Notes\n -----\n Changes in scipy 0.8.0: rewrite to add tie-handling, and axis.\n\n References\n ----------\n\n .. [1] Zwillinger, D. and Kokoska, S. (2000). CRC Standard\n Probability and Statistics Tables and Formulae. Chapman & Hall: New\n York. 2000.\n Section 14.7\n\n Examples\n --------\n >>> from scipy import stats\n >>> stats.spearmanr([1,2,3,4,5], [5,6,7,8,7])\n (0.82078268166812329, 0.088587005313543798)\n >>> np.random.seed(1234321)\n >>> x2n = np.random.randn(100, 2)\n >>> y2n = np.random.randn(100, 2)\n >>> stats.spearmanr(x2n)\n (0.059969996999699973, 0.55338590803773591)\n >>> stats.spearmanr(x2n[:,0], x2n[:,1])\n (0.059969996999699973, 0.55338590803773591)\n >>> rho, pval = stats.spearmanr(x2n, y2n)\n >>> rho\n array([[ 1. , 0.05997 , 0.18569457, 0.06258626],\n [ 0.05997 , 1. , 0.110003 , 0.02534653],\n [ 0.18569457, 0.110003 , 1. , 0.03488749],\n [ 0.06258626, 0.02534653, 0.03488749, 1. ]])\n >>> pval\n array([[ 0. , 0.55338591, 0.06435364, 0.53617935],\n [ 0.55338591, 0. , 0.27592895, 0.80234077],\n [ 0.06435364, 0.27592895, 0. , 0.73039992],\n [ 0.53617935, 0.80234077, 0.73039992, 0. ]])\n >>> rho, pval = stats.spearmanr(x2n.T, y2n.T, axis=1)\n >>> rho\n array([[ 1. , 0.05997 , 0.18569457, 0.06258626],\n [ 0.05997 , 1. , 0.110003 , 0.02534653],\n [ 0.18569457, 0.110003 , 1. , 0.03488749],\n [ 0.06258626, 0.02534653, 0.03488749, 1. ]])\n >>> stats.spearmanr(x2n, y2n, axis=None)\n (0.10816770419260482, 0.1273562188027364)\n >>> stats.spearmanr(x2n.ravel(), y2n.ravel())\n (0.10816770419260482, 0.1273562188027364)\n\n >>> xint = np.random.randint(10, size=(100, 2))\n >>> stats.spearmanr(xint)\n (0.052760927029710199, 0.60213045837062351)\n\n \"\"\"\n a, axisout = _chk_asarray(a, axis)\n ar = np.apply_along_axis(rankdata, axisout, a)\n\n br = None\n if b is not None:\n b, axisout = _chk_asarray(b, axis)\n br = np.apply_along_axis(rankdata, axisout, b)\n n = a.shape[axisout]\n rs = np.corrcoef(ar, br, rowvar=axisout)\n\n olderr = np.seterr(divide='ignore') # rs can have elements equal to 1\n try:\n t = rs * np.sqrt((n-2) / ((rs+1.0)*(1.0-rs)))\n finally:\n np.seterr(**olderr)\n\n prob = 2 * distributions.t.sf(np.abs(t), n-2)\n if rs.shape == (2, 2):\n return rs[1,0], prob[1,0]\n else:\n return rs, prob\n\n\ndef pointbiserialr(x, y):\n \"\"\"Calculates a point biserial correlation coefficient and the associated\n p-value.\n\n The point biserial correlation is used to measure the relationship\n between a binary variable, x, and a continuous variable, y. Like other\n correlation coefficients, this one varies between -1 and +1 with 0\n implying no correlation. Correlations of -1 or +1 imply a determinative\n relationship.\n\n This function uses a shortcut formula but produces the same result as\n `pearsonr`.\n\n Parameters\n ----------\n x : array_like of bools\n Input array.\n y : array_like\n Input array.\n\n Returns\n -------\n r : float\n R value\n p-value : float\n 2-tailed p-value\n\n References\n ----------\n http://en.wikipedia.org/wiki/Point-biserial_correlation_coefficient\n\n Examples\n --------\n >>> from scipy import stats\n >>> a = np.array([0, 0, 0, 1, 1, 1, 1])\n >>> b = np.arange(7)\n >>> stats.pointbiserialr(a, b)\n (0.8660254037844386, 0.011724811003954652)\n >>> stats.pearsonr(a, b)\n (0.86602540378443871, 0.011724811003954626)\n >>> np.corrcoef(a, b)\n array([[ 1. , 0.8660254],\n [ 0.8660254, 1. ]])\n\n \"\"\"\n x = np.asarray(x, dtype=bool)\n y = np.asarray(y, dtype=float)\n n = len(x)\n\n # phat is the fraction of x values that are True\n phat = x.sum() / float(len(x))\n y0 = y[~x] # y-values where x is False\n y1 = y[x] # y-values where x is True\n y0m = y0.mean()\n y1m = y1.mean()\n\n # phat - phat**2 is more stable than phat*(1-phat)\n rpb = (y1m - y0m) * np.sqrt(phat - phat**2) / y.std()\n\n df = n - 2\n # fixme: see comment about TINY in pearsonr()\n TINY = 1e-20\n t = rpb * np.sqrt(df / ((1.0 - rpb + TINY)*(1.0 + rpb + TINY)))\n prob = betai(0.5*df, 0.5, df/(df+t*t))\n return rpb, prob\n\n\ndef kendalltau(x, y, initial_lexsort=True):\n \"\"\"\n Calculates Kendall's tau, a correlation measure for ordinal data.\n\n Kendall's tau is a measure of the correspondence between two rankings.\n Values close to 1 indicate strong agreement, values close to -1 indicate\n strong disagreement. This is the tau-b version of Kendall's tau which\n accounts for ties.\n\n Parameters\n ----------\n x, y : array_like\n Arrays of rankings, of the same shape. If arrays are not 1-D, they will\n be flattened to 1-D.\n initial_lexsort : bool, optional\n Whether to use lexsort or quicksort as the sorting method for the\n initial sort of the inputs. Default is lexsort (True), for which\n `kendalltau` is of complexity O(n log(n)). If False, the complexity is\n O(n^2), but with a smaller pre-factor (so quicksort may be faster for\n small arrays).\n\n Returns\n -------\n Kendall's tau : float\n The tau statistic.\n p-value : float\n The two-sided p-value for a hypothesis test whose null hypothesis is\n an absence of association, tau = 0.\n\n Notes\n -----\n The definition of Kendall's tau that is used is::\n\n tau = (P - Q) / sqrt((P + Q + T) * (P + Q + U))\n\n where P is the number of concordant pairs, Q the number of discordant\n pairs, T the number of ties only in `x`, and U the number of ties only in\n `y`. If a tie occurs for the same pair in both `x` and `y`, it is not\n added to either T or U.\n\n References\n ----------\n W.R. Knight, \"A Computer Method for Calculating Kendall's Tau with\n Ungrouped Data\", Journal of the American Statistical Association, Vol. 61,\n No. 314, Part 1, pp. 436-439, 1966.\n\n Examples\n --------\n >>> from scipy import stats\n >>> x1 = [12, 2, 1, 12, 2]\n >>> x2 = [1, 4, 7, 1, 0]\n >>> tau, p_value = stats.kendalltau(x1, x2)\n >>> tau\n -0.47140452079103173\n >>> p_value\n 0.24821309157521476\n\n \"\"\"\n x = np.asarray(x).ravel()\n y = np.asarray(y).ravel()\n\n if not x.size or not y.size:\n return (np.nan, np.nan) # Return NaN if arrays are empty\n\n n = np.int64(len(x))\n temp = list(range(n)) # support structure used by mergesort\n # this closure recursively sorts sections of perm[] by comparing\n # elements of y[perm[]] using temp[] as support\n # returns the number of swaps required by an equivalent bubble sort\n\n def mergesort(offs, length):\n exchcnt = 0\n if length == 1:\n return 0\n if length == 2:\n if y[perm[offs]] <= y[perm[offs+1]]:\n return 0\n t = perm[offs]\n perm[offs] = perm[offs+1]\n perm[offs+1] = t\n return 1\n length0 = length // 2\n length1 = length - length0\n middle = offs + length0\n exchcnt += mergesort(offs, length0)\n exchcnt += mergesort(middle, length1)\n if y[perm[middle - 1]] < y[perm[middle]]:\n return exchcnt\n\n # merging\n i = j = k = 0\n while j < length0 or k < length1:\n if k >= length1 or (j < length0 and y[perm[offs + j]] <=\n y[perm[middle + k]]):\n temp[i] = perm[offs + j]\n d = i - j\n j += 1\n else:\n temp[i] = perm[middle + k]\n d = (offs + i) - (middle + k)\n k += 1\n if d > 0:\n exchcnt += d\n i += 1\n perm[offs:offs+length] = temp[0:length]\n return exchcnt\n\n # initial sort on values of x and, if tied, on values of y\n if initial_lexsort:\n # sort implemented as mergesort, worst case: O(n log(n))\n perm = np.lexsort((y, x))\n else:\n # sort implemented as quicksort, 30% faster but with worst case: O(n^2)\n perm = list(range(n))\n perm.sort(key=lambda a: (x[a], y[a]))\n\n # compute joint ties\n first = 0\n t = 0\n for i in xrange(1, n):\n if x[perm[first]] != x[perm[i]] or y[perm[first]] != y[perm[i]]:\n t += ((i - first) * (i - first - 1)) // 2\n first = i\n t += ((n - first) * (n - first - 1)) // 2\n\n # compute ties in x\n first = 0\n u = 0\n for i in xrange(1, n):\n if x[perm[first]] != x[perm[i]]:\n u += ((i - first) * (i - first - 1)) // 2\n first = i\n u += ((n - first) * (n - first - 1)) // 2\n\n # count exchanges\n exchanges = mergesort(0, n)\n # compute ties in y after mergesort with counting\n first = 0\n v = 0\n for i in xrange(1, n):\n if y[perm[first]] != y[perm[i]]:\n v += ((i - first) * (i - first - 1)) // 2\n first = i\n v += ((n - first) * (n - first - 1)) // 2\n\n tot = (n * (n - 1)) // 2\n if tot == u or tot == v:\n return np.nan, np.nan # Special case for all ties in both ranks\n\n # Prevent overflow; equal to np.sqrt((tot - u) * (tot - v))\n denom = np.exp(0.5 * (np.log(tot - u) + np.log(tot - v)))\n tau = ((tot - (v + u - t)) - 2.0 * exchanges) / denom\n\n # what follows reproduces the ending of Gary Strangman's original\n # stats.kendalltau() in SciPy\n svar = (4.0 * n + 10.0) / (9.0 * n * (n - 1))\n z = tau / np.sqrt(svar)\n prob = special.erfc(np.abs(z) / 1.4142136)\n\n return tau, prob\n\n\ndef linregress(x, y=None):\n \"\"\"\n Calculate a regression line\n\n This computes a least-squares regression for two sets of measurements.\n\n Parameters\n ----------\n x, y : array_like\n two sets of measurements. Both arrays should have the same length.\n If only x is given (and y=None), then it must be a two-dimensional\n array where one dimension has length 2. The two sets of measurements\n are then found by splitting the array along the length-2 dimension.\n\n Returns\n -------\n slope : float\n slope of the regression line\n intercept : float\n intercept of the regression line\n r-value : float\n correlation coefficient\n p-value : float\n two-sided p-value for a hypothesis test whose null hypothesis is\n that the slope is zero.\n stderr : float\n Standard error of the estimate\n\n\n Examples\n --------\n >>> from scipy import stats\n >>> x = np.random.random(10)\n >>> y = np.random.random(10)\n >>> slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)\n\n # To get coefficient of determination (r_squared)\n\n >>> print(\"r-squared:\", r_value**2)\n r-squared: 0.15286643777\n\n \"\"\"\n TINY = 1.0e-20\n if y is None: # x is a (2, N) or (N, 2) shaped array_like\n x = asarray(x)\n if x.shape[0] == 2:\n x, y = x\n elif x.shape[1] == 2:\n x, y = x.T\n else:\n msg = (\"If only `x` is given as input, it has to be of shape \"\n \"(2, N) or (N, 2), provided shape was %s\" % str(x.shape))\n raise ValueError(msg)\n else:\n x = asarray(x)\n y = asarray(y)\n n = len(x)\n xmean = np.mean(x, None)\n ymean = np.mean(y, None)\n\n # average sum of squares:\n ssxm, ssxym, ssyxm, ssym = np.cov(x, y, bias=1).flat\n r_num = ssxym\n r_den = np.sqrt(ssxm * ssym)\n if r_den == 0.0:\n r = 0.0\n else:\n r = r_num / r_den\n # test for numerical error propagation\n if r > 1.0:\n r = 1.0\n elif r < -1.0:\n r = -1.0\n\n df = n - 2\n t = r * np.sqrt(df / ((1.0 - r + TINY)*(1.0 + r + TINY)))\n prob = 2 * distributions.t.sf(np.abs(t), df)\n slope = r_num / ssxm\n intercept = ymean - slope*xmean\n sterrest = np.sqrt((1 - r**2) * ssym / ssxm / df)\n return slope, intercept, r, prob, sterrest\n\n\ndef theilslopes(y, x=None, alpha=0.95):\n r\"\"\"\n Computes the Theil-Sen estimator for a set of points (x, y).\n\n `theilslopes` implements a method for robust linear regression. It\n computes the slope as the median of all slopes between paired values.\n\n Parameters\n ----------\n y : array_like\n Dependent variable.\n x : {None, array_like}, optional\n Independent variable. If None, use ``arange(len(y))`` instead.\n alpha : float\n Confidence degree between 0 and 1. Default is 95% confidence.\n Note that `alpha` is symmetric around 0.5, i.e. both 0.1 and 0.9 are\n interpreted as \"find the 90% confidence interval\".\n\n Returns\n -------\n medslope : float\n Theil slope.\n medintercept : float\n Intercept of the Theil line, as ``median(y) - medslope*median(x)``.\n lo_slope : float\n Lower bound of the confidence interval on `medslope`.\n up_slope : float\n Upper bound of the confidence interval on `medslope`.\n\n Notes\n -----\n The implementation of `theilslopes` follows [1]_. The intercept is\n not defined in [1]_, and here it is defined as ``median(y) -\n medslope*median(x)``, which is given in [3]_. Other definitions of\n the intercept exist in the literature. A confidence interval for\n the intercept is not given as this question is not addressed in\n [1]_.\n\n References\n ----------\n .. [1] P.K. Sen, \"Estimates of the regression coefficient based on Kendall's tau\",\n J. Am. Stat. Assoc., Vol. 63, pp. 1379-1389, 1968.\n .. [2] H. Theil, \"A rank-invariant method of linear and polynomial\n regression analysis I, II and III\", Nederl. Akad. Wetensch., Proc.\n 53:, pp. 386-392, pp. 521-525, pp. 1397-1412, 1950.\n .. [3] W.L. Conover, \"Practical nonparametric statistics\", 2nd ed.,\n John Wiley and Sons, New York, pp. 493.\n\n Examples\n --------\n >>> from scipy import stats\n >>> import matplotlib.pyplot as plt\n\n >>> x = np.linspace(-5, 5, num=150)\n >>> y = x + np.random.normal(size=x.size)\n >>> y[11:15] += 10 # add outliers\n >>> y[-5:] -= 7\n\n Compute the slope, intercept and 90% confidence interval. For comparison,\n also compute the least-squares fit with `linregress`:\n\n >>> res = stats.theilslopes(y, x, 0.90)\n >>> lsq_res = stats.linregress(x, y)\n\n Plot the results. The Theil-Sen regression line is shown in red, with the\n dashed red lines illustrating the confidence interval of the slope (note\n that the dashed red lines are not the confidence interval of the regression\n as the confidence interval of the intercept is not included). The green\n line shows the least-squares fit for comparison.\n\n >>> fig = plt.figure()\n >>> ax = fig.add_subplot(111)\n >>> ax.plot(x, y, 'b.')\n >>> ax.plot(x, res[1] + res[0] * x, 'r-')\n >>> ax.plot(x, res[1] + res[2] * x, 'r--')\n >>> ax.plot(x, res[1] + res[3] * x, 'r--')\n >>> ax.plot(x, lsq_res[1] + lsq_res[0] * x, 'g-')\n >>> plt.show()\n\n \"\"\"\n y = np.asarray(y).flatten()\n if x is None:\n x = np.arange(len(y), dtype=float)\n else:\n x = np.asarray(x, dtype=float).flatten()\n if len(x) != len(y):\n raise ValueError(\"Incompatible lengths ! (%s<>%s)\" % (len(y), len(x)))\n\n # Compute sorted slopes only when deltax > 0\n deltax = x[:, np.newaxis] - x\n deltay = y[:, np.newaxis] - y\n slopes = deltay[deltax > 0] / deltax[deltax > 0]\n slopes.sort()\n medslope = np.median(slopes)\n medinter = np.median(y) - medslope * np.median(x)\n # Now compute confidence intervals\n if alpha > 0.5:\n alpha = 1. - alpha\n\n z = distributions.norm.ppf(alpha / 2.)\n # This implements (2.6) from Sen (1968)\n _, nxreps = find_repeats(x)\n _, nyreps = find_repeats(y)\n nt = len(slopes) # N in Sen (1968)\n ny = len(y) # n in Sen (1968)\n # Equation 2.6 in Sen (1968):\n sigsq = 1/18. * (ny * (ny-1) * (2*ny+5) -\n np.sum(k * (k-1) * (2*k + 5) for k in nxreps) -\n np.sum(k * (k-1) * (2*k + 5) for k in nyreps))\n # Find the confidence interval indices in `slopes`\n sigma = np.sqrt(sigsq)\n Ru = min(int(np.round((nt - z*sigma)/2.)), len(slopes)-1)\n Rl = max(int(np.round((nt + z*sigma)/2.)) - 1, 0)\n delta = slopes[[Rl, Ru]]\n return medslope, medinter, delta[0], delta[1]\n\n\n#####################################\n##### INFERENTIAL STATISTICS #####\n#####################################\n\ndef ttest_1samp(a, popmean, axis=0):\n \"\"\"\n Calculates the T-test for the mean of ONE group of scores.\n\n This is a two-sided test for the null hypothesis that the expected value\n (mean) of a sample of independent observations `a` is equal to the given\n population mean, `popmean`.\n\n Parameters\n ----------\n a : array_like\n sample observation\n popmean : float or array_like\n expected value in null hypothesis, if array_like than it must have the\n same shape as `a` excluding the axis dimension\n axis : int, optional, (default axis=0)\n Axis can equal None (ravel array first), or an integer (the axis\n over which to operate on a).\n\n Returns\n -------\n t : float or array\n t-statistic\n prob : float or array\n two-tailed p-value\n\n Examples\n --------\n >>> from scipy import stats\n\n >>> np.random.seed(7654567) # fix seed to get the same result\n >>> rvs = stats.norm.rvs(loc=5, scale=10, size=(50,2))\n\n Test if mean of random sample is equal to true mean, and different mean.\n We reject the null hypothesis in the second case and don't reject it in\n the first case.\n\n >>> stats.ttest_1samp(rvs,5.0)\n (array([-0.68014479, -0.04323899]), array([ 0.49961383, 0.96568674]))\n >>> stats.ttest_1samp(rvs,0.0)\n (array([ 2.77025808, 4.11038784]), array([ 0.00789095, 0.00014999]))\n\n Examples using axis and non-scalar dimension for population mean.\n\n >>> stats.ttest_1samp(rvs,[5.0,0.0])\n (array([-0.68014479, 4.11038784]), array([ 4.99613833e-01, 1.49986458e-04]))\n >>> stats.ttest_1samp(rvs.T,[5.0,0.0],axis=1)\n (array([-0.68014479, 4.11038784]), array([ 4.99613833e-01, 1.49986458e-04]))\n >>> stats.ttest_1samp(rvs,[[5.0],[0.0]])\n (array([[-0.68014479, -0.04323899],\n [ 2.77025808, 4.11038784]]), array([[ 4.99613833e-01, 9.65686743e-01],\n [ 7.89094663e-03, 1.49986458e-04]]))\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n n = a.shape[axis]\n df = n - 1\n\n d = np.mean(a, axis) - popmean\n v = np.var(a, axis, ddof=1)\n denom = np.sqrt(v / float(n))\n\n t = np.divide(d, denom)\n t, prob = _ttest_finish(df, t)\n\n return t, prob\n\n\ndef _ttest_finish(df, t):\n \"\"\"Common code between all 3 t-test functions.\"\"\"\n prob = distributions.t.sf(np.abs(t), df) * 2 # use np.abs to get upper tail\n if t.ndim == 0:\n t = t[()]\n\n return t, prob\n\n\ndef ttest_ind(a, b, axis=0, equal_var=True):\n \"\"\"\n Calculates the T-test for the means of TWO INDEPENDENT samples of scores.\n\n This is a two-sided test for the null hypothesis that 2 independent samples\n have identical average (expected) values. This test assumes that the\n populations have identical variances.\n\n Parameters\n ----------\n a, b : array_like\n The arrays must have the same shape, except in the dimension\n corresponding to `axis` (the first, by default).\n axis : int, optional\n Axis can equal None (ravel array first), or an integer (the axis\n over which to operate on a and b).\n equal_var : bool, optional\n If True (default), perform a standard independent 2 sample test\n that assumes equal population variances [1]_.\n If False, perform Welch's t-test, which does not assume equal\n population variance [2]_.\n\n .. versionadded:: 0.11.0\n\n Returns\n -------\n t : float or array\n The calculated t-statistic.\n prob : float or array\n The two-tailed p-value.\n\n Notes\n -----\n We can use this test, if we observe two independent samples from\n the same or different population, e.g. exam scores of boys and\n girls or of two ethnic groups. The test measures whether the\n average (expected) value differs significantly across samples. If\n we observe a large p-value, for example larger than 0.05 or 0.1,\n then we cannot reject the null hypothesis of identical average scores.\n If the p-value is smaller than the threshold, e.g. 1%, 5% or 10%,\n then we reject the null hypothesis of equal averages.\n\n References\n ----------\n .. [1] http://en.wikipedia.org/wiki/T-test#Independent_two-sample_t-test\n\n .. [2] http://en.wikipedia.org/wiki/Welch%27s_t_test\n\n Examples\n --------\n >>> from scipy import stats\n >>> np.random.seed(12345678)\n\n Test with sample with identical means:\n\n >>> rvs1 = stats.norm.rvs(loc=5,scale=10,size=500)\n >>> rvs2 = stats.norm.rvs(loc=5,scale=10,size=500)\n >>> stats.ttest_ind(rvs1,rvs2)\n (0.26833823296239279, 0.78849443369564776)\n >>> stats.ttest_ind(rvs1,rvs2, equal_var = False)\n (0.26833823296239279, 0.78849452749500748)\n\n `ttest_ind` underestimates p for unequal variances:\n\n >>> rvs3 = stats.norm.rvs(loc=5, scale=20, size=500)\n >>> stats.ttest_ind(rvs1, rvs3)\n (-0.46580283298287162, 0.64145827413436174)\n >>> stats.ttest_ind(rvs1, rvs3, equal_var = False)\n (-0.46580283298287162, 0.64149646246569292)\n\n When n1 != n2, the equal variance t-statistic is no longer equal to the\n unequal variance t-statistic:\n\n >>> rvs4 = stats.norm.rvs(loc=5, scale=20, size=100)\n >>> stats.ttest_ind(rvs1, rvs4)\n (-0.99882539442782481, 0.3182832709103896)\n >>> stats.ttest_ind(rvs1, rvs4, equal_var = False)\n (-0.69712570584654099, 0.48716927725402048)\n\n T-test with different means, variance, and n:\n\n >>> rvs5 = stats.norm.rvs(loc=8, scale=20, size=100)\n >>> stats.ttest_ind(rvs1, rvs5)\n (-1.4679669854490653, 0.14263895620529152)\n >>> stats.ttest_ind(rvs1, rvs5, equal_var = False)\n (-0.94365973617132992, 0.34744170334794122)\n\n \"\"\"\n a, b, axis = _chk2_asarray(a, b, axis)\n if a.size == 0 or b.size == 0:\n return (np.nan, np.nan)\n\n v1 = np.var(a, axis, ddof=1)\n v2 = np.var(b, axis, ddof=1)\n n1 = a.shape[axis]\n n2 = b.shape[axis]\n\n if equal_var:\n df = n1 + n2 - 2\n svar = ((n1 - 1) * v1 + (n2 - 1) * v2) / float(df)\n denom = np.sqrt(svar * (1.0 / n1 + 1.0 / n2))\n else:\n vn1 = v1 / n1\n vn2 = v2 / n2\n df = ((vn1 + vn2)**2) / ((vn1**2) / (n1 - 1) + (vn2**2) / (n2 - 1))\n\n # If df is undefined, variances are zero (assumes n1 > 0 & n2 > 0).\n # Hence it doesn't matter what df is as long as it's not NaN.\n df = np.where(np.isnan(df), 1, df)\n denom = np.sqrt(vn1 + vn2)\n\n d = np.mean(a, axis) - np.mean(b, axis)\n t = np.divide(d, denom)\n t, prob = _ttest_finish(df, t)\n\n return t, prob\n\n\ndef ttest_rel(a, b, axis=0):\n \"\"\"\n Calculates the T-test on TWO RELATED samples of scores, a and b.\n\n This is a two-sided test for the null hypothesis that 2 related or\n repeated samples have identical average (expected) values.\n\n Parameters\n ----------\n a, b : array_like\n The arrays must have the same shape.\n axis : int, optional, (default axis=0)\n Axis can equal None (ravel array first), or an integer (the axis\n over which to operate on a and b).\n\n Returns\n -------\n t : float or array\n t-statistic\n prob : float or array\n two-tailed p-value\n\n Notes\n -----\n Examples for the use are scores of the same set of student in\n different exams, or repeated sampling from the same units. The\n test measures whether the average score differs significantly\n across samples (e.g. exams). If we observe a large p-value, for\n example greater than 0.05 or 0.1 then we cannot reject the null\n hypothesis of identical average scores. If the p-value is smaller\n than the threshold, e.g. 1%, 5% or 10%, then we reject the null\n hypothesis of equal averages. Small p-values are associated with\n large t-statistics.\n\n References\n ----------\n http://en.wikipedia.org/wiki/T-test#Dependent_t-test\n\n Examples\n --------\n >>> from scipy import stats\n >>> np.random.seed(12345678) # fix random seed to get same numbers\n\n >>> rvs1 = stats.norm.rvs(loc=5,scale=10,size=500)\n >>> rvs2 = (stats.norm.rvs(loc=5,scale=10,size=500) +\n ... stats.norm.rvs(scale=0.2,size=500))\n >>> stats.ttest_rel(rvs1,rvs2)\n (0.24101764965300962, 0.80964043445811562)\n >>> rvs3 = (stats.norm.rvs(loc=8,scale=10,size=500) +\n ... stats.norm.rvs(scale=0.2,size=500))\n >>> stats.ttest_rel(rvs1,rvs3)\n (-3.9995108708727933, 7.3082402191726459e-005)\n\n \"\"\"\n a, b, axis = _chk2_asarray(a, b, axis)\n if a.shape[axis] != b.shape[axis]:\n raise ValueError('unequal length arrays')\n\n if a.size == 0 or b.size == 0:\n return np.nan, np.nan\n\n n = a.shape[axis]\n df = float(n - 1)\n\n d = (a - b).astype(np.float64)\n v = np.var(d, axis, ddof=1)\n dm = np.mean(d, axis)\n denom = np.sqrt(v / float(n))\n\n t = np.divide(dm, denom)\n t, prob = _ttest_finish(df, t)\n\n return t, prob\n\n\ndef kstest(rvs, cdf, args=(), N=20, alternative='two-sided', mode='approx'):\n \"\"\"\n Perform the Kolmogorov-Smirnov test for goodness of fit.\n\n This performs a test of the distribution G(x) of an observed\n random variable against a given distribution F(x). Under the null\n hypothesis the two distributions are identical, G(x)=F(x). The\n alternative hypothesis can be either 'two-sided' (default), 'less'\n or 'greater'. The KS test is only valid for continuous distributions.\n\n Parameters\n ----------\n rvs : str, array or callable\n If a string, it should be the name of a distribution in `scipy.stats`.\n If an array, it should be a 1-D array of observations of random\n variables.\n If a callable, it should be a function to generate random variables;\n it is required to have a keyword argument `size`.\n cdf : str or callable\n If a string, it should be the name of a distribution in `scipy.stats`.\n If `rvs` is a string then `cdf` can be False or the same as `rvs`.\n If a callable, that callable is used to calculate the cdf.\n args : tuple, sequence, optional\n Distribution parameters, used if `rvs` or `cdf` are strings.\n N : int, optional\n Sample size if `rvs` is string or callable. Default is 20.\n alternative : {'two-sided', 'less','greater'}, optional\n Defines the alternative hypothesis (see explanation above).\n Default is 'two-sided'.\n mode : 'approx' (default) or 'asymp', optional\n Defines the distribution used for calculating the p-value.\n\n - 'approx' : use approximation to exact distribution of test statistic\n - 'asymp' : use asymptotic distribution of test statistic\n\n Returns\n -------\n D : float\n KS test statistic, either D, D+ or D-.\n p-value : float\n One-tailed or two-tailed p-value.\n\n Notes\n -----\n In the one-sided test, the alternative is that the empirical\n cumulative distribution function of the random variable is \"less\"\n or \"greater\" than the cumulative distribution function F(x) of the\n hypothesis, ``G(x)<=F(x)``, resp. ``G(x)>=F(x)``.\n\n Examples\n --------\n >>> from scipy import stats\n\n >>> x = np.linspace(-15, 15, 9)\n >>> stats.kstest(x, 'norm')\n (0.44435602715924361, 0.038850142705171065)\n\n >>> np.random.seed(987654321) # set random seed to get the same result\n >>> stats.kstest('norm', False, N=100)\n (0.058352892479417884, 0.88531190944151261)\n\n The above lines are equivalent to:\n\n >>> np.random.seed(987654321)\n >>> stats.kstest(stats.norm.rvs(size=100), 'norm')\n (0.058352892479417884, 0.88531190944151261)\n\n *Test against one-sided alternative hypothesis*\n\n Shift distribution to larger values, so that ``cdf_dgp(x) < norm.cdf(x)``:\n\n >>> np.random.seed(987654321)\n >>> x = stats.norm.rvs(loc=0.2, size=100)\n >>> stats.kstest(x,'norm', alternative = 'less')\n (0.12464329735846891, 0.040989164077641749)\n\n Reject equal distribution against alternative hypothesis: less\n\n >>> stats.kstest(x,'norm', alternative = 'greater')\n (0.0072115233216311081, 0.98531158590396395)\n\n Don't reject equal distribution against alternative hypothesis: greater\n\n >>> stats.kstest(x,'norm', mode='asymp')\n (0.12464329735846891, 0.08944488871182088)\n\n *Testing t distributed random variables against normal distribution*\n\n With 100 degrees of freedom the t distribution looks close to the normal\n distribution, and the K-S test does not reject the hypothesis that the\n sample came from the normal distribution:\n\n >>> np.random.seed(987654321)\n >>> stats.kstest(stats.t.rvs(100,size=100),'norm')\n (0.072018929165471257, 0.67630062862479168)\n\n With 3 degrees of freedom the t distribution looks sufficiently different\n from the normal distribution, that we can reject the hypothesis that the\n sample came from the normal distribution at the 10% level:\n\n >>> np.random.seed(987654321)\n >>> stats.kstest(stats.t.rvs(3,size=100),'norm')\n (0.131016895759829, 0.058826222555312224)\n\n \"\"\"\n if isinstance(rvs, string_types):\n if (not cdf) or (cdf == rvs):\n cdf = getattr(distributions, rvs).cdf\n rvs = getattr(distributions, rvs).rvs\n else:\n raise AttributeError(\"if rvs is string, cdf has to be the \"\n \"same distribution\")\n\n if isinstance(cdf, string_types):\n cdf = getattr(distributions, cdf).cdf\n if callable(rvs):\n kwds = {'size': N}\n vals = np.sort(rvs(*args, **kwds))\n else:\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":2275,"numItemsPerPage":100,"numTotalItems":228459,"offset":227500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4Njk0Njk1NSwianRpIjoiZDg1NDc2MDItMTU0MC00NjhkLThkM2ItYzk0YjAzYjExOTNmIiwic3ViIjoiL2RhdGFzZXRzL0phY2tCaW5hcnkvTWl4ZWRUZXh0LTIiLCJleHAiOjE3ODY5NTA1NTUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.LJLJjs9IPw_71DiABtHeRo-18E22Ol5hgxIQE_UJ0K-XK-cstvH73zn5-h0soaKYKJcPnxOwgDKacFk-WAOhDg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":228459,"numBytesParquet":7695109915}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
text stringlengths 5.09k 178k | domain stringclasses 106
values |
|---|---|
"""Beautiful Soup
Elixir and Tonic
"The Screen-Scraper's Friend"
http://www.crummy.com/software/BeautifulSoup/
Beautiful Soup parses a (possibly invalid) XML or HTML document into a
tree representation. It provides methods and Pythonic idioms that make
it easy to navigate, search, and modify the tree.
A well-formed X... | codeparrot/github-code-clean |
#!/usr/bin/env python
# -*- coding: latin-1 -*-
"""Generate Python documentation in HTML or text for interactive use.
In the Python interpreter, do "from pydoc import help" to provide online
help. Calling help(thing) on a Python object documents the object.
Or, at the shell command line outside of Python:
Run "pydo... | codeparrot/github-code-clean |
import time
from copy import deepcopy
from Foundation import NSArray
from AppKit import NSOnOffButton, NSRoundRectBezelStyle, NSDate, NSColor, NSFontNameAttribute, \
NSFormatter, NSTextField, NSTextView, NSTextFieldCell, NSView, NSNoTabsNoBorder, NSButton, NSObject, \
NSDecimalNumber, NSString, NSInsetRect, NSN... | codeparrot/github-code-clean |
#######################################################################
#
# Copyright 2009-2011 by Ullrich Koethe
#
# This file is part of the VIGRA computer vision library.
# The VIGRA Website is
# http://hci.iwr.uni-heidelberg.de/vigra/
# Please direct questions, bug reports, and contributions... | codeparrot/github-code-clean |
# Neural networks, from the simple perceptron to deep learning
## To do list
* write code for single perceptron model and make link with linear regression
* revise initial info and add references
* Update tensorflow material, with keras
* think of adding material about pytorch
* rework pulsar example and breast c... | codeparrot/github-code-clean |
#!/usr/bin/env python
"""Module cma implements the CMA-ES (Covariance Matrix Adaptation Evolution Strategy).
CMA-ES is a stochastic optimizer for robust non-linear non-convex
derivative- and function-value-free numerical optimization.
This implementation can be used with Python versions 2.6, 2.7, 3.x.
CMA-ES... | codeparrot/github-code-clean |
from __future__ import division
from copy import copy, deepcopy
from six import PY2
from enigma import BT_SCALE, RT_HALIGN_CENTER, RT_HALIGN_LEFT, RT_HALIGN_RIGHT, RT_VALIGN_BOTTOM, RT_VALIGN_CENTER, RT_VALIGN_TOP, eListboxPythonMultiContent, getPrevAsciiCode, gFont
import six
from skin import fonts, parameters
from ... | codeparrot/github-code-clean |
# patch.py - patch file parsing routines
#
# Copyright 2006 Brendan Cully <brendan@kublai.com>
# Copyright 2007 Chris Mason <chris.mason@oracle.com>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from __future__ import absolute_i... | codeparrot/github-code-clean |
# coding=utf-8
import json
import logging
from collections import Counter
from datetime import datetime
from typing import Iterable
from homematicip.base.enums import *
from homematicip.base.helpers import get_functional_channel, get_functional_channels
from homematicip.base.HomeMaticIPObject import HomeMaticIPObject
... | codeparrot/github-code-clean |
#!/usr/bin/env python
# This file is part of nexdatas - Tango Server for NeXus data writer
#
# Copyright (C) 2012-2014 DESY, Jan Kotanski <jkotan@mail.desy.de>
#
# nexdatas is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the ... | codeparrot/github-code-clean |
#!/usr/bin/env python
#
# Electrum - lightweight Bitcoin client
# Copyright (C) 2012 thomasv@gitorious
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU... | codeparrot/github-code-clean |
# -*- coding: utf8 -*-
#***************************************************************************
#* *
#* Copyright (c) 2009, 2010 *
#* Yorik van Havre <yorik@uncreated.net>, Ken Cline <cline@frii... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
'''Unit tests for models and their factories.'''
import mock
import unittest
from nose.tools import * # noqa (PEP8 asserts)
import pytz
import datetime
import urlparse
from dateutil import parser
from modularodm.exceptions import ValidationError, ValidationValueError, ValidationTypeError
fr... | codeparrot/github-code-clean |
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not us... | codeparrot/github-code-clean |
""" Data objects in group "Setpoint Managers"
"""
from collections import OrderedDict
import logging
from pyidf.helper import DataObject
logger = logging.getLogger("pyidf")
logger.addHandler(logging.NullHandler())
class SetpointManagerScheduled(DataObject):
""" Corresponds to IDD object `SetpointManager:Sched... | codeparrot/github-code-clean |
###############################################################################
#
# Worksheet - A class for writing the Excel XLSX Worksheet file.
#
# Copyright 2013-2016, John McNamara, jmcnamara@cpan.org
#
# Standard packages.
import re
import tempfile
import codecs
import os
from warnings import warn
# Standard p... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
# Copyright (c) 2016-2017, Zhijiang Yao, Jie Dong and Dongsheng Cao
# All rights reserved.
# This file is part of the PyBioMed.
# The contents are covered by the terms of the BSD license
# which is included in the file license.txt, found at the root
# of the PyBioMed source tree.
"""
This ... | codeparrot/github-code-clean |
from functools import wraps
from sys import getsizeof
from typing import (
TYPE_CHECKING,
Any,
Callable,
Hashable,
Iterable,
List,
Optional,
Sequence,
Tuple,
Union,
)
import warnings
import numpy as np
from pandas._config import get_option
from pandas._libs import algos as lib... | codeparrot/github-code-clean |
"""
A MathML printer.
"""
from __future__ import print_function, division
from sympy import sympify, S, Mul
from sympy.core.compatibility import range, string_types, default_sort_key
from sympy.core.function import _coeff_isneg
from sympy.printing.conventions import split_super_sub, requires_partial
from sympy.printi... | codeparrot/github-code-clean |
"""
Provide a generic structure to support window functions,
similar to how we have a Groupby object.
"""
from __future__ import annotations
import copy
from datetime import timedelta
from functools import partial
import inspect
from textwrap import dedent
from typing import (
TYPE_CHECKING,
Any,
Callable,... | codeparrot/github-code-clean |
# Authors: Alexandre Gramfort <alexandre.gramfort@inria.fr>
# Mathieu Blondel <mathieu@mblondel.org>
# Olivier Grisel <olivier.grisel@ensta.org>
# Andreas Mueller <amueller@ais.uni-bonn.de>
# Eric Martin <eric@ericmart.in>
# Giorgio Patrini <giorgio.patrini@anu.edu.au>
# Lic... | codeparrot/github-code-clean |
import json
import unittest2
import webtest
from datetime import datetime
from google.appengine.ext import ndb
from google.appengine.ext import deferred
from google.appengine.api import taskqueue
from google.appengine.ext import testbed
import api_main
import tba_config
from consts.award_type import AwardType
from c... | codeparrot/github-code-clean |
from sqlalchemy.test.testing import eq_, assert_raises, assert_raises_message
import datetime, re, operator
from sqlalchemy import *
from sqlalchemy import exc, sql, util
from sqlalchemy.sql import table, column, label, compiler
from sqlalchemy.sql.expression import ClauseList
from sqlalchemy.engine import default
from... | codeparrot/github-code-clean |
# Copyright (c) 2012 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from compiler.ast import Const
from compiler.ast import Dict
from compiler.ast import Discard
from compiler.ast import List
from compiler.ast import Module
from co... | codeparrot/github-code-clean |
import xbmcaddon, xbmcvfs
from htmltoxbmc import HTMLConverter
import re, os, sys, time, urllib2, urlparse
import xbmc, xbmcgui #@UnresolvedImport
import mechanize, threading # @UnresolvedImport
import YDStreamExtractor as StreamExtractor
import YDStreamUtils as StreamUtils
StreamExtractor.overrideParam('noplaylist',... | codeparrot/github-code-clean |
## NIFTY (Numerical Information Field Theory) has been developed at the
## Max-Planck-Institute for Astrophysics.
##
## Copyright (C) 2013 Max-Planck-Society
##
## Author: Marco Selig
## Project homepage: <http://www.mpa-garching.mpg.de/ift/nifty/>
##
## This program is free software: you can redistribute it and/or mod... | codeparrot/github-code-clean |
## This module comprehends some routines to generate a simple datafile
## with/without header, that can be read in by pgfplots
## and routines to write a tex file to plot from a given file
import os
import commands
from io_routines import convert_filename_to_path_and_filename, sorted_nicely, sortdiff, get_relative_path... | codeparrot/github-code-clean |
#!/usr/bin/env python2
#
# Email: Hagen Paul Pfeifer <hagen@jauu.net>
# URL: http://research.protocollabs.com/captcp/
# Captcp is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, ... | codeparrot/github-code-clean |
# Copyright (C) 2006--2015 Kipp Cannon
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 3 of the License, or (at your
# option) any later version.
#
# This program is distribute... | codeparrot/github-code-clean |
# coding=utf-8
# 上面的程式內容編碼必須在程式的第一或者第二行才會有作用
################# (1) 模組導入區
# 導入 cherrypy 模組, 為了在 OpenShift 平台上使用 cherrypy 模組, 必須透過 setup.py 安裝
import cherrypy
# 導入 Python 內建的 os 模組, 因為 os 模組為 Python 內建, 所以無需透過 setup.py 安裝
import os
# 導入 random 模組
import random
import math
from cherrypy.lib.static import serve_file
# ... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
'''
*GSASIIstrMath - structure math routines*
-----------------------------------------
'''
########### SVN repository information ###################
# $Date: 2018-06-13 20:58:28 +0300 (Wed, 13 Jun 2018) $
# $Author: vondreele $
# $Revision: 3433 $
# $URL: https://subversion.xray.aps.a... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
#!/usr/bin/python
"""Test of line navigation output of Firefox on the Orca wiki.
Note that this is based on the following Firefox 3 build:
Gecko/2007122122 Minefield/3.0b3pre. In addition, it is using
the current patch to bug 505102 to handle a significant change
made in the current Firefox. ... | codeparrot/github-code-clean |
# Copyright 2018 The TensorFlow Probability Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law o... | codeparrot/github-code-clean |
# Copyright 2011 VMware, Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by ... | codeparrot/github-code-clean |
# Copyright (c) 2013 OpenStack Foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to ... | codeparrot/github-code-clean |
# Copyright 2012 OpenStack Foundation.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless req... | codeparrot/github-code-clean |
""" Cisco_IOS_XR_snmp_agent_oper
This module contains a collection of YANG definitions
for Cisco IOS\-XR snmp\-agent package operational data.
This module contains definitions
for the following management objects\:
snmp\: SNMP operational data
Copyright (c) 2013\-2015 by Cisco Systems, Inc.
All rights reserved.
... | codeparrot/github-code-clean |
### extends 'class_empty.py'
### block ClassImports
# NOTICE: Do not edit anything here, it is generated code
from . import gxapi_cy
from geosoft.gxapi import GXContext, float_ref, int_ref, str_ref
### endblock ClassImports
### block Header
# NOTICE: The code generator will not replace the code in this block
### end... | codeparrot/github-code-clean |
from collections import defaultdict
from sympy import SYMPY_DEBUG
from sympy.core import (Basic, S, C, Add, Mul, Pow, Rational, Integer,
Derivative, Wild, Symbol, sympify, expand, expand_mul, expand_func,
Function, Equality, Dummy, Atom, count_ops, Expr, factor_terms,
expand_multinomial)
from sympy.core.... | codeparrot/github-code-clean |
# configobj.py
# A config file reader/writer that supports nested sections in config files.
# Copyright (C) 2005-2010 Michael Foord, Nicola Larosa
# E-mail: fuzzyman AT voidspace DOT org DOT uk
# nico AT tekNico DOT net
# ConfigObj 4
# http://www.voidspace.org.uk/python/configobj.html
# Released subject to th... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
# Test the support for SSL and sockets
import sys
import unittest
from test import test_support as support
from test.script_helper import assert_python_ok
import asyncore
import socket
import select
import time
import datetime
import gc
import os
import errno
import pprint
import tempfile
impor... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
""" Utilities
@requires: U{B{I{gluon}} <http://web2py.com>}
@copyright: (c) 2010-2015 Sahana Software Foundation
@license: MIT
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Softwa... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
from __future__ import print_function
from __future__ import absolute_import
from __future__ import division
import numpy as np
import types as python_types
import warnings
import copy
import os
from six.moves import zip
from .. import backend as K
from ..utils.io_utils import ask_to_proceed_... | codeparrot/github-code-clean |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# $Id: vboxshell.py $
"""
VirtualBox Python Shell.
This program is a simple interactive shell for VirtualBox. You can query
information and issue commands from a simple command line.
It also provides you with examples on how to use VirtualBox's Python API.
This shell is e... | codeparrot/github-code-clean |
"""A set of classes used during the parsing of VB code"""
# << Definitions >>
StopSearch = -9999 # Used to terminate searches for parent properties
# -- end -- << Definitions >>
# << Classes >> (1 of 75)
class VBElement(object):
"""An element of VB code"""
# << VBElement methods >> (1 of 2)
def __init__(s... | codeparrot/github-code-clean |
"""
matplotlib includes a framework for arbitrary geometric
transformations that is used determine the final position of all
elements drawn on the canvas.
Transforms are composed into trees of :class:`TransformNode` objects
whose actual value depends on their children. When the contents of
children change, their pare... | codeparrot/github-code-clean |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
#======================================================================
#
# emake.py - emake version 3.30
#
# history of this file:
# 2009.08.20 skywind create this file
# 2009.11.14 skywind new install() method
# 2009.12.22 skywind implementation execute inter... | codeparrot/github-code-clean |
# Copyright 2012 VMware, Inc.
# All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by a... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
from django.conf import settings
if __name__ == '__main__':
# When running this file in isolation, we need to set up the configuration
# before importing 'template'.
settings.configure()
from datetime import date, datetime, ... | codeparrot/github-code-clean |
# pylint: disable=E1101
from warnings import catch_warnings
from datetime import datetime, timedelta
from functools import partial
from textwrap import dedent
import pytest
import numpy as np
import pandas as pd
import pandas.tseries.offsets as offsets
import pandas.util.testing as tm
from pandas import (Series, Dat... | codeparrot/github-code-clean |
#!/usr/bin/env python3
# Copyright (c) 2019-2020 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
# Test Taproot softfork (BIPs 340-342)
from test_framework.blocktools import (
create_coinbase,
c... | codeparrot/github-code-clean |
# coding: utf-8
from __future__ import unicode_literals
import binascii
import collections
import email
import getpass
import io
import optparse
import os
import re
import shlex
import shutil
import socket
import struct
import subprocess
import sys
import itertools
import xml.etree.ElementTree
try:
import urllib... | codeparrot/github-code-clean |
"""
Modulestore backed by Mongodb.
Stores individual XModules as single documents with the following
structure:
{
'_id': <location.as_dict>,
'metadata': <dict containing all Scope.settings fields>
'definition': <dict containing all Scope.content fields>
'definition.children': <list of all child locati... | codeparrot/github-code-clean |
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
Tests for implementations of L{IReactorTCP} and the TCP parts of
L{IReactorSocket}.
"""
from __future__ import division, absolute_import
__metaclass__ = type
import errno
import socket
from functools import wraps
from zope.interface impor... | codeparrot/github-code-clean |
from collections import Iterable
from numbers import Real, Integral
import sys
from six import string_types
import numpy as np
import h5py
import openmc
import openmc.mgxs
from openmc.checkvalue import check_type, check_value, check_greater_than, \
check_iterable_type, check_less_than
# Supported incoming parti... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# Name: interval.py
# Purpose: music21 classes for representing intervals
#
# Authors: Michael Scott Cuthbert
# Jackie Rogoff
# Amy Hailes
# Christopher A... | codeparrot/github-code-clean |
"""tests of joined-eager loaded attributes"""
from sqlalchemy.testing import eq_, is_, is_not_
import sqlalchemy as sa
from sqlalchemy import testing
from sqlalchemy.orm import joinedload, deferred, undefer, \
joinedload_all, backref, eagerload, Session, immediateload
from sqlalchemy import Integer, String, Date, ... | codeparrot/github-code-clean |
################################################################################
# Copyright 2016-2022 Advanced Micro Devices, Inc. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in t... | codeparrot/github-code-clean |
from nose.tools import assert_equal
from nose.tools import assert_raises
import numpy as np
from numpy import ma
import matplotlib
from matplotlib.testing.decorators import image_comparison, cleanup
import matplotlib.pyplot as plt
@image_comparison(baseline_images=['formatter_ticker_001',
... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
"""
A Cell
A cell is a single input/output block. Worksheets are built out of
a list of cells.
"""
###########################################################################
# Copyright (C) 2006 William Stein <wstein@gmail.com>
#
# Distributed under the terms of the GNU General Public ... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
"""
/***************************************************************************
topog4qgis A QGIS plugin Tools for managing Topographic tool on vector
layers
-----------------------------
begin : 2013-10-30
copyright ... | codeparrot/github-code-clean |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# The Qubes OS Project, http://www.qubes-os.org
#
# Copyright (C) 2013 Marek Marczykowski-Górecki <marmarek@invisiblethingslab.com>
# Copyright (C) 2013 Olivier Médoc <o_medoc@yahoo.fr>
#
# This program is free software; you can redistribute it and/or
# modify it under the ... | codeparrot/github-code-clean |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#from time import sleep
from fakeclassRdm import fakeRdm, fakeReadXMLString
#from classEditor import Editor
import unittest
#from xml.dom import minidom
class barreSimpleTestCase(unittest.TestCase) :
def setUp(self):
self.rdm = self._genere_instance()
def _... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
import logging
import time
from datetime import datetime
import uuid
import sets
from functools import partial
import openerp
import openerp.addons.decimal_precision as dp
from openerp import tools, models, SUPERUSER_I... | codeparrot/github-code-clean |
# Copyright 2010 United States Government as represented by the
# Administrator of the National Aeronautics and Space Administration.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a ... | codeparrot/github-code-clean |
# ------------------------------------------------------------------------------
# Copyright 2021 Esri
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICEN... | codeparrot/github-code-clean |
# Copyright 2017 Google LLC.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
#... | codeparrot/github-code-clean |
from collections import OrderedDict
from itertools import product
import pytest
import warnings
from warnings import catch_warnings
from datetime import datetime, timedelta
from numpy.random import randn
import numpy as np
import pandas as pd
from pandas import (Series, DataFrame, bdate_range,
isn... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
##
## This file is part of Invenio.
## Copyright (C) 2009, 2010, 2011, 2019 CERN.
##
## Invenio is free software; you can redistribute it and/or
## modify it under the terms of the GNU General Public License as
## published by the Free Software Foundation; either version 2 of the
## License, or ... | codeparrot/github-code-clean |
#!/usr/bin/env python3
import ipaddress
import random
import socket
import struct
import unittest
from io import BytesIO
import scapy.compat
from framework import VppTestCase, VppTestRunner
from ipfix import IPFIX, Set, Template, Data, IPFIXDecoder
from scapy.all import bind_layers, Packet, ByteEnumField, ShortField,... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
from boxbranding import getMachineBuild, getMachineBrand, getMachineName
from Tools.Profile import profile
from Screen import Screen
import Screens.InfoBar
import Components.ParentalControl
from Components.Button import Button
from Components.ServiceList import ServiceList, refreshServiceList
f... | codeparrot/github-code-clean |
"""
Instructor Dashboard API views
JSON views which the instructor dashboard requests.
Many of these GETs may become PUTs in the future.
"""
import StringIO
import json
import logging
import re
import time
import requests
from django.conf import settings
from django.views.decorators.csrf import ensure_csrf_cookie
fro... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
# These expanded material design icons are maintained by Austin Andrews
# (Templarian on Github). They can be found at materialdesignicons.com.
#
# LAST UPDATED: Version 1.7.22
#
# For those updating from an older version of KivyMD, icon names have
# changed/updated (e.g. square-o is now checkb... | codeparrot/github-code-clean |
"""tfutils tests.
These tests show basic procedures for training, validating, and extracting features from
models.
Note about MongoDB:
The tests require a MongoDB instance to be available on the port defined by "testport" in
the code below. This db can either be local to where you run these tests (and therefore
on ... | codeparrot/github-code-clean |
from sqlalchemy.testing import eq_, assert_raises_message, assert_raises, is_
from sqlalchemy import testing
from sqlalchemy.testing import fixtures, engines
from sqlalchemy import util
import datetime
from sqlalchemy import *
from sqlalchemy import exc, sql
from sqlalchemy.engine import default, result as _result
from... | codeparrot/github-code-clean |
# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
# Copyright 2014-2016 Florian Bruhin (The Compiler) <mail@qutebrowser.org>
#
# This file is part of qutebrowser.
#
# qutebrowser is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free S... | codeparrot/github-code-clean |
r""" ciscoconfparse.py - Parse, Query, Build, and Modify IOS-style configs
Copyright (C) 2021-2022 David Michael Pennington
Copyright (C) 2021 David Michael Pennington
Copyright (C) 2020-2021 David Michael Pennington at Cisco Systems
Copyright (C) 2019 David Michael Pennington at Thousand... | codeparrot/github-code-clean |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
try:
from lxml import etree as ET
except ImportError:
import xml.etree.ElementTree as ET
#import xml.etree.ElementTree as ET
# ТЕКСТ НИЖЕ НИ В КОЕМ СЛУЧАЕ НЕЛЬЗЯ РЕДАКТИРОВАТЬ!
info = '''
Created on 18 октября 2016 г.
Relise : 16.11.2016
@author: Ан... | codeparrot/github-code-clean |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Bottle is a fast and simple micro-framework for small web applications. It
offers request dispatching (Routes) with URL parameter support, templates,
a built-in HTTP Server and adapters for many third party WSGI/HTTP-server and
template engines - all in a single file an... | codeparrot/github-code-clean |
# SimpleCV Cameras & Devices
#load system libraries
from SimpleCV.base import *
from SimpleCV.ImageClass import Image, ImageSet, ColorSpace
from SimpleCV.Display import Display
from SimpleCV.Color import Color
from collections import deque
import time
import ctypes as ct
import subprocess
import cv2
import numpy as np... | codeparrot/github-code-clean |
"""
A Printer which converts an expression into its LaTeX equivalent.
"""
from __future__ import print_function, division
from sympy.core import S, Add, Symbol
from sympy.core.function import _coeff_isneg
from sympy.core.sympify import SympifyError
from sympy.core.alphabets import greeks
from sympy.core.operations im... | codeparrot/github-code-clean |
from collections import OrderedDict
import copy
import itertools
from numbers import Integral
import os
import numpy as np
import openmc
import openmc.checkvalue as cv
from openmc.mgxs import MGXS
from .mgxs import _DOMAIN_TO_FILTER
# Supported cross section types
MDGXS_TYPES = (
'delayed-nu-fission',
'chi-... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
try:
# Python 2.7
from collections import OrderedDict
except:
# Python 2.6
from gluon.contrib.simplejson.ordered_dict import OrderedDict
from datetime import timedelta
from gluon import current, Field, URL
from gluon.html import *
from gluon.storage import Storage
from gluon.v... | codeparrot/github-code-clean |
#! /usr/bin/env python
"""
This script performs event averaging for particle
spectra and anisotropic flow coefficients calculated
from event-by-event simulations
v_n is analyzed up to n = 6
Format for particle_XXX_vndata.dat file:
n_order real_part real_part_err imag_part imag_part... | codeparrot/github-code-clean |
# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.
from __future__ import absolute_import, division, print_function
import binascii
import ipaddress
import os
import pytest
import six
fr... | codeparrot/github-code-clean |
#!/usr/bin/env python
"""Create a "virtual" Python installation
"""
# If you change the version here, change it in setup.py
# and docs/conf.py as well.
__version__ = "1.8.4" # following best practices
virtualenv_version = __version__ # legacy, again
import base64
import sys
import os
import codecs
import optparse
i... | codeparrot/github-code-clean |
#!/usr/bin/env python3
import logging
from collections import defaultdict
from errno import ENOENT
from stat import S_IFDIR, S_IFLNK, S_IFREG, S_ISDIR, S_ISREG
from sys import argv, exit
from time import time, sleep
from fuse import FUSE, FuseOSError, Operations, LoggingMixIn
import socket
import sys
import select
im... | codeparrot/github-code-clean |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Bottle is a fast and simple micro-framework for small web applications. It
offers request dispatching (Routes) with url parameter support, templates,
a built-in HTTP Server and adapters for many third party WSGI/HTTP-server and
template engines - all in a single file an... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
##
## This file is part of Invenio.
## Copyright (C) 2006, 2007, 2008, 2010, 2011, 2013 CERN.
##
## Invenio is free software; you can redistribute it and/or
## modify it under the terms of the GNU General Public License as
## published by the Free Software Foundation; either version 2 of the
## ... | codeparrot/github-code-clean |
#!/usr/bin/env python
"""Create a "virtual" Python installation
"""
# If you change the version here, change it in setup.py
# and docs/conf.py as well.
virtualenv_version = "1.6"
import base64
import sys
import os
import optparse
import re
import shutil
import logging
import tempfile
import zlib
import errno
import ... | codeparrot/github-code-clean |
__author__ = 'Benjamin Moran'
from pyglet import compat_platform
# def get_guid(device):
# """Generate a Game Controller GUID from a joystick device.
#
# :param device: a pyglet joystick device
# :return: SDL2 format Game Controller GUID
#
# """
# if compat_platform.startswith("linux"):
# ... | codeparrot/github-code-clean |
# -*- coding:utf-8 -*-
## src/config.py
##
## Copyright (C) 2003-2005 Vincent Hanquez <tab AT snarc.org>
## Copyright (C) 2003-2014 Yann Leboulanger <asterix AT lagaule.org>
## Copyright (C) 2005 Alex Podaras <bigpod AT gmail.com>
## Stéphan Kochen <stephan AT kochen.nl>
## Copyright (C) 2005-2006 Di... | codeparrot/github-code-clean |
# Copyright 2014 Red Hat, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | codeparrot/github-code-clean |
# Copyright 2015 ClusterHQ. See LICENSE file for details.
"""
Tests for `libzfs_core` operations.
These are mostly functional and conformance tests that validate
that the operations produce expected effects or fail with expected
exceptions.
"""
import unittest
import contextlib
import errno
import filecmp
import os
... | codeparrot/github-code-clean |
# Copyright (c) 2010-2013 OpenStack Foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agree... | codeparrot/github-code-clean |
# Copyright 2010 OpenStack Foundation
# Copyright 2012 University Of Minho
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.... | codeparrot/github-code-clean |
from __future__ import absolute_import
from __future__ import print_function
from typing import Tuple
from django.conf import settings
from django.core import validators
from django.contrib.sessions.models import Session
from zerver.lib.cache import flush_user_profile
from zerver.lib.context_managers import lockfile
f... | codeparrot/github-code-clean |
# coding: utf-8
"""
RedfishvApi.py
Copyright 2015 SmartBear Software
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required ... | codeparrot/github-code-clean |
# Copyright (c) Gary Strangman. All rights reserved
#
# Disclaimer
#
# This software is provided "as-is". There are no expressed or implied
# warranties of any kind, including, but not limited to, the warranties
# of merchantability and fitness for a given application. In no event
# shall Gary Strangman be liable fo... | codeparrot/github-code-clean |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.