Exemple #1
0
 def test_revision_url_to_parts(self):
     rcache = revision_cache.RevisionCache(self.get_test_dir(),
                                           'hg.mozilla.org')
     repo, rev = rcache.revision_url_to_parts(
         "http://hg.mozilla.org/releases/mozilla-release/rev/e55e45536133")
     self.assertEquals(repo, "releases/mozilla-release")
     self.assertEquals(rev, "e55e45536133")
Exemple #2
0
    def test_get_revision(self):
        rcache = revision_cache.RevisionCache(self.get_test_dir(),
                                              'hg.mozilla.org')

        # Check one that's pre-cached:
        pc_repo = 'releases/mozilla-release'
        pc_rev = '0488055e9f9f'
        ref = self.check_one(pc_repo, pc_rev, rcache)
        self.assertNotIn(pc_repo, rcache._repos)

        revision = rcache.get_revision(pc_repo, pc_rev)
        self.assertEqual(revision, ref)
        self.assertIn(pc_repo, rcache._repos)
        self.assertIn(pc_rev, rcache._repos[pc_repo])
        # This time it should be cached:
        revision = rcache.get_revision(pc_repo, pc_rev)
        self.assertEqual(revision, ref)

        # Fetch another one that's not cached
        nc_repo = 'releases/mozilla-beta'
        nc_rev = '53c447ff5fd3'
        self.assertNotIn(nc_repo, rcache._repos)
        revision = rcache.get_revision(nc_repo, nc_rev)
        self.assertIn("A11Y_INSTANTIATED_FLAG", revision)
        self.assertIn(nc_repo, rcache._repos)
        self.assertIn(nc_rev, rcache._repos[nc_repo])
def main(argv=None):
    parser = argparse.ArgumentParser(description="Convert Telemetry data")
    parser.add_argument("-c",
                        "--config-file",
                        help="Read configuration from this file",
                        default="./telemetry_server_config.json")
    parser.add_argument("-d",
                        "--date",
                        help="Use specified date for dimensions")
    args = parser.parse_args()

    try:
        server_config = open(args.config_file, "r")
        config = json.load(server_config)
        server_config.close()
    except IOError:
        config = {}

    cache_dir = config.get("revision_cache_path", "./histogram_cache")
    server = config.get("revision_cache_server", "hg.mozilla.org")
    schema_filename = config.get("schema_filename", "./telemetry_schema.json")
    schema_data = open(schema_filename)
    schema = TelemetrySchema(json.load(schema_data))
    schema_data.close()

    cache = revision_cache.RevisionCache(cache_dir, server)
    converter = Converter(cache, schema)
    process(converter, args.date)
Exemple #4
0
 def check_one_url(self, url, cache=None):
     #print "checking url", url
     if cache is None:
         dummy = revision_cache.RevisionCache(self.get_test_dir(),
                                              'hg.mozilla.org')
     else:
         dummy = cache
     repo, rev = dummy.revision_url_to_parts(url)
     return self.check_one(repo, rev, cache)
def check_one(repo, rev):
    rcache = revision_cache.RevisionCache(cache_dir, 'hg.mozilla.org')
    filename = "%s/%s/%s/Histograms.json" % (cache_dir, repo, rev)
    assert not os.path.exists(filename)
    bad = rcache.fetch_disk(repo, rev)
    assert bad is None
    remote = rcache.fetch_server(repo, rev)
    assert "A11Y_INSTANTIATED_FLAG" in remote
    good = rcache.fetch_disk(repo, rev)
    assert "A11Y_INSTANTIATED_FLAG" in good
    assert os.path.exists(filename)
Exemple #6
0
    def setUpClass(cls):
        cls.cache_dir = "/tmp/histogram_revision_cache"
        cls.schema_filename = "./telemetry/telemetry_schema.json"
        assert not os.path.exists(cls.cache_dir)

        schema_file = open(cls.schema_filename, "r")
        cls.schema = TelemetrySchema(json.load(schema_file))
        schema_file.close()
        cls.cache = revision_cache.RevisionCache(cls.cache_dir,
                                                 'hg.mozilla.org')
        cls.converter = Converter(cls.cache, cls.schema)
Exemple #7
0
    def test_get_revision_noparse(self):
        rcache = revision_cache.RevisionCache(self.get_test_dir(),
                                              'hg.mozilla.org')
        # Fetch one that's not cached
        repo = 'releases/mozilla-beta'
        rev = '53c447ff5fd3'
        self.assertNotIn(repo, rcache._repos)
        revision = rcache.get_revision(repo, rev, parse=False)
        self.assertIn("A11Y_INSTANTIATED_FLAG", revision)
        self.assertIn(repo, rcache._repos)
        self.assertIn(rev, rcache._repos[repo])

        # parse=False should give us a raw string. Parse it as json and then
        # make sure the same key is present.
        parsed = json.loads(revision)
        self.assertIn("A11Y_INSTANTIATED_FLAG", parsed)
Exemple #8
0
 def check_one(self, repo, rev, cache=None):
     #print "checking repo:", repo, "rev:", rev
     if cache is None:
         rcache = revision_cache.RevisionCache(self.get_test_dir(),
                                               'hg.mozilla.org')
     else:
         rcache = cache
     filename = "%s/%s/%s/Histograms.json" % (self.get_test_dir(), repo,
                                              rev)
     self.assertFalse(os.path.exists(filename))
     bad = rcache.fetch_disk(repo, rev)
     self.assertIs(bad, None)
     remote = rcache.fetch_server(repo, rev)
     self.assertIn("A11Y_INSTANTIATED_FLAG", remote)
     good = rcache.fetch_disk(repo, rev)
     self.assertIn("A11Y_INSTANTIATED_FLAG", good)
     self.assertTrue(os.path.exists(filename))
     return good
Exemple #9
0
 def test_bad_revision_url_to_parts(self):
     rcache = revision_cache.RevisionCache(self.get_test_dir(),
                                           'hg.mozilla.org')
     with self.assertRaises(ValueError):
         repo, rev = rcache.revision_url_to_parts("arglebargle")