def test_tzaware_datetime_support(self): """Test that using timezone aware datetime instances works with the MinTimeUUID/MaxTimeUUID functions. """ pk = uuid4() midpoint_utc = datetime.utcnow().replace(tzinfo=TzOffset(0)) midpoint_helsinki = midpoint_utc.astimezone(TzOffset(3)) # Assert pre-condition that we have the same logical point in time assert midpoint_utc.utctimetuple() == midpoint_helsinki.utctimetuple() assert midpoint_utc.timetuple() != midpoint_helsinki.timetuple() TimeUUIDQueryModel.create(partition=pk, time=uuid_from_time(midpoint_utc - timedelta(minutes=1)), data='1') TimeUUIDQueryModel.create(partition=pk, time=uuid_from_time(midpoint_utc), data='2') TimeUUIDQueryModel.create(partition=pk, time=uuid_from_time(midpoint_utc + timedelta(minutes=1)), data='3') assert ['1', '2'] == [ o.data for o in TimeUUIDQueryModel.filter( TimeUUIDQueryModel.partition == pk, TimeUUIDQueryModel.time <= functions.MaxTimeUUID(midpoint_utc)) ] assert ['1', '2'] == [ o.data for o in TimeUUIDQueryModel.filter( TimeUUIDQueryModel.partition == pk, TimeUUIDQueryModel.time <= functions.MaxTimeUUID(midpoint_helsinki)) ] assert ['2', '3'] == [ o.data for o in TimeUUIDQueryModel.filter( TimeUUIDQueryModel.partition == pk, TimeUUIDQueryModel.time >= functions.MinTimeUUID(midpoint_utc)) ] assert ['2', '3'] == [ o.data for o in TimeUUIDQueryModel.filter( TimeUUIDQueryModel.partition == pk, TimeUUIDQueryModel.time >= functions.MinTimeUUID(midpoint_helsinki)) ]
def save_normal(normals, loc, scale, size, race_obj): """ Saves a race_normal to C* raceNormalId = columns.UUID(primary_key=True, default=uuid.uuid4) raceId = columns.UUID(primary_key=True, default=uuid.uuid4) petCategoryName = columns.Text(required=False) petCategoryId = columns.UUID(primary_key=True, default=uuid.uuid4) currentTime = columns.DateTime() normals = columns.List() normalLoc = columns.Float() normalScale = columns.Float() normalSize = columns.Tuple() """ dt = datetime.utcnow() uuid = uuid_from_time(datetime.utcnow()) RaceNormal.create( raceNormalId=uuid, raceId=race_obj['raceId'], petCategoryName=race_obj['petCategoryName'], petCategoryId=race_obj['petCategoryId'], currentTime=dt, normals=normals, normalLoc=loc, normalScale=scale, normalSize=size ) PetRaceCassandraDataStore.increment_counter_by_name('RaceNormal')
def update_race(self, current_race, current_racers): for key, value in current_racers.items(): uuid = uuid_from_time(datetime.utcnow()) RaceResult.create( raceResultId=uuid, raceId=current_race['raceId'], raceParticipantId=key, petName=value['petName'], petCategoryName=current_race['petCategoryName'], finishPosition=value['finish_position'], finishTime=value['finish_time'], startTime=current_race['startTime'] ) PetRaceCassandraDataStore.increment_counter_by_name('RaceResult') metrics = self.cluster.metrics.stats hosts = int(metrics.known_hosts()) connected_to = int(metrics.connected_to()) open_connections = int(metrics.open_connections()) Metric.create( metricId=uuid_from_time(datetime.utcnow()), connectionErrors=metrics.connection_errors, writeTimeouts=metrics.write_timeouts, readTimeouts=metrics.read_timeouts, unavailables=metrics.unavailables, otherErrors=metrics.other_errors, retries=metrics.retries, ignores=metrics.ignores, knownHosts=hosts, connectedTo=connected_to, openConnections=open_connections, reqCount=metrics.request_timer['count'], reqMinLatency=metrics.request_timer['min'], reqMaxLatency=metrics.request_timer['max'], reqMeanLatency=metrics.request_timer['mean'], reqStdev=metrics.request_timer['stdev'], reqMedian=metrics.request_timer['median'], req75percentile=metrics.request_timer['75percentile'], req97percentile=metrics.request_timer['97percentile'], req98percentile=metrics.request_timer['98percentile'], req99percentile=metrics.request_timer['99percentile'], req999percentile=metrics.request_timer['999percentile'], dateCreated=datetime.utcnow(), )
def test_tzaware_datetime_support(self): """Test that using timezone aware datetime instances works with the MinTimeUUID/MaxTimeUUID functions. """ pk = uuid4() midpoint_utc = datetime.utcnow().replace(tzinfo=TzOffset(0)) midpoint_helsinki = midpoint_utc.astimezone(TzOffset(3)) # Assert pre-condition that we have the same logical point in time assert midpoint_utc.utctimetuple() == midpoint_helsinki.utctimetuple() assert midpoint_utc.timetuple() != midpoint_helsinki.timetuple() TimeUUIDQueryModel.create( partition=pk, time=uuid_from_time(midpoint_utc - timedelta(minutes=1)), data='1') TimeUUIDQueryModel.create( partition=pk, time=uuid_from_time(midpoint_utc), data='2') TimeUUIDQueryModel.create( partition=pk, time=uuid_from_time(midpoint_utc + timedelta(minutes=1)), data='3') assert ['1', '2'] == [o.data for o in TimeUUIDQueryModel.filter( TimeUUIDQueryModel.partition == pk, TimeUUIDQueryModel.time <= functions.MaxTimeUUID(midpoint_utc))] assert ['1', '2'] == [o.data for o in TimeUUIDQueryModel.filter( TimeUUIDQueryModel.partition == pk, TimeUUIDQueryModel.time <= functions.MaxTimeUUID(midpoint_helsinki))] assert ['2', '3'] == [o.data for o in TimeUUIDQueryModel.filter( TimeUUIDQueryModel.partition == pk, TimeUUIDQueryModel.time >= functions.MinTimeUUID(midpoint_utc))] assert ['2', '3'] == [o.data for o in TimeUUIDQueryModel.filter( TimeUUIDQueryModel.partition == pk, TimeUUIDQueryModel.time >= functions.MinTimeUUID(midpoint_helsinki))]
def add_message(request): print request.user b = json.loads(request.body) raw_date_submit = datetime.utcnow() date_submit = raw_date_submit.date() uuid_time = uuid_from_time(raw_date_submit) bind_values = ['*****@*****.**',date_submit,uuid_time,b['content']] db_connection.bind_and_execute_stmt('INSERT',bind_values) return HttpResponse(json.dumps([{'email_id' : '*****@*****.**' , 'date_happened' : date_submit.isoformat() , 'event_time' : unix_time_from_uuid1(uuid_time) , 'content' : b['content']}]))
def from_datetime(self, dt): """ generates a UUID for a given datetime :param dt: datetime :type dt: datetime :return: """ msg = "cqlengine.columns.TimeUUID.from_datetime is deprecated. Use cassandra.util.uuid_from_time instead." warnings.warn(msg, DeprecationWarning) log.warning(msg) return util.uuid_from_time(dt)
def save_pet_categories(self, categories): self.connect_cass() for cat in categories: speed = float(cat['speed']) PetCategory.create( petCategoryId=uuid_from_time(datetime.utcnow()), name=cat['name'], speed=speed ) self.logger.debug("pet cat created: %s", cat['name'])
def test_conversion_specific_date(self): dt = datetime(1981, 7, 11, microsecond=555000) uuid = util.uuid_from_time(dt) from uuid import UUID assert isinstance(uuid, UUID) ts = (uuid.time - 0x01b21dd213814000) / 1e7 # back to a timestamp new_dt = datetime.utcfromtimestamp(ts) # checks that we created a UUID1 with the proper timestamp assert new_dt == dt
def update_race(self, current_race, current_racers): for key, value in current_racers.items(): uuid = uuid_from_time(datetime.utcnow()) RaceResult.create( raceResultId=uuid, raceId=current_race['raceId'], raceParticipantId=key, petName=value['petName'], petCategoryName=current_race['petCategoryName'], finishPosition=value['finish_position'], finishTime=value['finish_time'], startTime=current_race['startTime'] ) PetRaceCassandraDataStore.increment_counter_by_name('RaceResult')
def insert(fec, correo, titulo, descripcion): cluster = Cluster(['master'], protocol_version=3) session = cluster.connect() myuuid = uuid_from_time(time.time()) #query = session.prepare("select * from soporte.tickets_por_rango_fechas where fec >= '2014-01-01' and fec <= '2015-12-31' ALLOW FILTERING") query = SimpleStatement( "INSERT INTO soporte.tickets_por_usuario_rango_fechas(fec,correo,idticket,titulo,descripcion)values(%s,%s,%s,%s,%s)", consistency_level=ConsistencyLevel.QUORUM) session.execute(query, (fec, correo, myuuid, titulo, descripcion)) query2 = SimpleStatement( "INSERT INTO soporte.tickets_por_rango_fechas(fec,correo,idticket,titulo,descripcion)values(%s,%s,%s,%s,%s)", consistency_level=ConsistencyLevel.QUORUM) session.execute(query2, (fec, correo, myuuid, titulo, descripcion)) return "<p>Ticket creado satisfactoriamente </p>"
def save_racer_current_point(current_race, racer, race_sample): uuid = uuid_from_time(datetime.utcnow()) RaceData.create( raceDataId=uuid, petId=racer['petId'], raceId=current_race['raceId'], petName=racer['petName'], petCategoryName=current_race['petCategoryName'], petCategoryId=current_race['petCategoryId'], interval=race_sample['sample_iteration'], runnerDistance=race_sample['distance_this_sample'], runnerPreviousDistance=race_sample['previous_distance'], startTime=current_race['startTime'], finished=race_sample['finished'] ) PetRaceCassandraDataStore.increment_counter_by_name('RaceData')
def insert_member(session, name=None, age=None): id = uuid_from_time(time.time()) session.execute( """ INSERT INTO {keyspace}.members (id, name, age) VALUES (%s, %s, %s); """.format(keyspace=KEYSPACE), ( id, name, age, )) return { 'id': str(id), 'name': name, 'age': age, }
def post(self): author_id = get_user_id_from_jwt() data = request.get_json(silent=True) type = data.get('type', 'text') chat_id = data.get('chat_id') message_id = str(uuid_from_time(time.time())) text = data.get('text', '') asset_name = data.get('asset_name', '') meta_data = data.get('meta_data', {}) connection.setup(hosts=CASSANDRA_HOSTS, default_keyspace=CHAT_KEYSPACE) if type not in ChatMessageByChatId.allowed_type: return make_response("Type not allowed. Only allowed type: " + ChatMessageByChatId.allowed_type, 403) if type == 'glimpse': seconds_allowed = meta_data.get('seconds_allowed', 10) effect = meta_data.get('effect') meta_data = { 'seconds_allowed': seconds_allowed, 'effect': effect } elif type == 'glimpse_narrative': path_id = meta_data.get('path_id') meta_data = { 'path_id': path_id, } meta_data = json.dumps(meta_data) ChatMessageByChatId.create( chat_id=chat_id, message_id=message_id, author_id=author_id, type=type, text=text, asset_name=asset_name, meta_data=meta_data, ) #self._message_sent(chat_id, author_id, text, asset_name) return { "success": True }
def from_datetime(self, dt): """ generates a UUID for a given datetime :param dt: datetime :type dt: datetime :return: uuid1 .. deprecated:: 2.6.0 Use :func:`cassandra.util.uuid_from_time` """ msg = "cqlengine.columns.TimeUUID.from_datetime is deprecated. Use cassandra.util.uuid_from_time instead." warnings.warn(msg, DeprecationWarning) log.warning(msg) return util.uuid_from_time(dt)
def test_uuid_from_time(self): t = time.time() seq = 0x2aa5 node = uuid.getnode() u = util.uuid_from_time(t, node, seq) # using AlmostEqual because time precision is different for # some platforms self.assertAlmostEqual(util.unix_time_from_uuid1(u), t, 4) self.assertEqual(u.node, node) self.assertEqual(u.clock_seq, seq) # random node u1 = util.uuid_from_time(t, clock_seq=seq) u2 = util.uuid_from_time(t, clock_seq=seq) self.assertAlmostEqual(util.unix_time_from_uuid1(u1), t, 4) self.assertAlmostEqual(util.unix_time_from_uuid1(u2), t, 4) self.assertEqual(u.clock_seq, seq) # not impossible, but we shouldn't get the same value twice self.assertNotEqual(u1.node, u2.node) # random seq u1 = util.uuid_from_time(t, node=node) u2 = util.uuid_from_time(t, node=node) self.assertAlmostEqual(util.unix_time_from_uuid1(u1), t, 4) self.assertAlmostEqual(util.unix_time_from_uuid1(u2), t, 4) self.assertEqual(u.node, node) # not impossible, but we shouldn't get the same value twice self.assertNotEqual(u1.clock_seq, u2.clock_seq) # node too large with self.assertRaises(ValueError): u = util.uuid_from_time(t, node=2**48) # clock_seq too large with self.assertRaises(ValueError): u = util.uuid_from_time(t, clock_seq=0x4000) # construct from datetime dt = util.datetime_from_timestamp(t) u = util.uuid_from_time(dt, node, seq) self.assertAlmostEqual(util.unix_time_from_uuid1(u), t, 4) self.assertEqual(u.node, node) self.assertEqual(u.clock_seq, seq)
def test_uuid_from_time(self): t = time.time() seq = 0x2aa5 node = uuid.getnode() u = util.uuid_from_time(t, node, seq) # using AlmostEqual because time precision is different for # some platforms self.assertAlmostEqual(util.unix_time_from_uuid1(u), t, 4) self.assertEqual(u.node, node) self.assertEqual(u.clock_seq, seq) # random node u1 = util.uuid_from_time(t, clock_seq=seq) u2 = util.uuid_from_time(t, clock_seq=seq) self.assertAlmostEqual(util.unix_time_from_uuid1(u1), t, 4) self.assertAlmostEqual(util.unix_time_from_uuid1(u2), t, 4) self.assertEqual(u.clock_seq, seq) # not impossible, but we shouldn't get the same value twice self.assertNotEqual(u1.node, u2.node) # random seq u1 = util.uuid_from_time(t, node=node) u2 = util.uuid_from_time(t, node=node) self.assertAlmostEqual(util.unix_time_from_uuid1(u1), t, 4) self.assertAlmostEqual(util.unix_time_from_uuid1(u2), t, 4) self.assertEqual(u.node, node) # not impossible, but we shouldn't get the same value twice self.assertNotEqual(u1.clock_seq, u2.clock_seq) # node too large with self.assertRaises(ValueError): u = util.uuid_from_time(t, node=2 ** 48) # clock_seq too large with self.assertRaises(ValueError): u = util.uuid_from_time(t, clock_seq=0x4000) # construct from datetime dt = util.datetime_from_timestamp(t) u = util.uuid_from_time(dt, node, seq) self.assertAlmostEqual(util.unix_time_from_uuid1(u), t, 4) self.assertEqual(u.node, node) self.assertEqual(u.clock_seq, seq)
def export(self, name, columns, points): """Write the points to the Cassandra cluster.""" logger.debug("Export {} stats to Cassandra".format(name)) # Remove non number stats and convert all to float (for Boolean) data = {k: float(v) for (k, v) in dict(zip(columns, points)).iteritems() if isinstance(v, Number)} # Write input to the Cassandra table try: self.session.execute( """ INSERT INTO localhost (plugin, time, stat) VALUES (%s, %s, %s) """, (name, uuid_from_time(datetime.now()), data) ) except Exception as e: logger.error("Cannot export {} stats to Cassandra ({})".format(name, e))
def cassandra_insert_colaborador(lids, comision, fec_inicio, nombre, salario): myuuid = uuid_from_time(time.time()) print('') print("------->MYUUID:::", myuuid) id_colaborador = str(myuuid) print("------->IDCOLABORADOR:::", id_colaborador) print("--->LIDS: ", lids) area = get_areas_for_colaborador(lids) print("----> AREA::", area) cluster = Cluster(['master'], protocol_version=3) session = cluster.connect() query = SimpleStatement( "INSERT INTO cpm.colaboradores(id_colaborador,area,comision,fec_inicio,nombre,salario)values(%s,%s,%s,%s,%s,%s)", consistency_level=ConsistencyLevel.QUORUM) session.execute(query, (id_colaborador, area, float(comision), fec_inicio, nombre, float(salario))) return "Colaborador ingresado correctamente"
def save_pets(self, pets_create, category_name): self.connect_cass() q = PetCategory.objects.filter(name=category_name) if len(q) is not 1: raise ValueError('category not found: ', category_name) pet_cat = q.first() for _p in pets_create: Pet.create( petId=uuid_from_time(datetime.utcnow()), name=_p['name'], description=_p['description'], petCategoryName=pet_cat['name'], petCategoryId=pet_cat['petCategoryId'], petSpeed=pet_cat['speed'] ) self.logger.debug("pet created: %s", _p['name'])
def genericize(columns, parameters): def date_handler(obj): return obj.isoformat() if hasattr(obj, 'isoformat') else obj parameters = flatten(deepcopy(parameters)) if 'id' not in parameters: if 'date' in parameters: parameters['id'] = uuid_from_time(parameters['date']) else: parameters['id'] = uuid.uuid4() generic = {'b_': {}, 'd_': {}, 'i_': {}, 'f_': {}, 's_': {}, 'l_': {}} for key, value in parameters.items(): if key not in columns: if type(value) is bool: prefix = 'b_' elif type(value) is datetime: prefix = 'd_' elif type(value) is int: prefix = 'i_' elif type(value) is float: prefix = 'f_' elif isinstance(value, (str, unicode)): prefix = 's_' elif type(value) is list: prefix = 'l_' value = '\n'.join([str(x) for x in value]) elif value is not None: prefix = 's_' value = json.dumps(value, default=date_handler) if value is not None: generic[prefix][prefix + key] = value del parameters[key] for key, value in generic.items(): if key in columns: parameters[key] = value for name in columns: if name not in parameters: parameters[name] = None return parameters
def export(self, name, columns, points): """Write the points to the Cassandra cluster.""" logger.debug("Export {} stats to Cassandra".format(name)) # Remove non number stats and convert all to float (for Boolean) data = { k: float(v) for (k, v) in dict(zip(columns, points)).iteritems() if isinstance(v, Number) } # Write input to the Cassandra table try: self.session.execute( """ INSERT INTO localhost (plugin, time, stat) VALUES (%s, %s, %s) """, (name, uuid_from_time(datetime.now()), data)) except Exception as e: logger.error("Cannot export {} stats to Cassandra ({})".format( name, e))
for _ in range(random.randint(5, 12))) + ".jpg" categoria_tupla = random.choice(categorias) categoria = categoria_tupla[0] nombre_categoria_es = categoria_tupla[1] nombre_categoria_en = categoria_tupla[2] nombre_categoria_fr = categoria_tupla[3] nombre_categoria = { 'es': nombre_categoria_es, 'en': nombre_categoria_en, 'fr': nombre_categoria_fr } timestamp_producto = random_date(start, end) alta_producto = timestamp_producto.strftime("%Y") codigo_referencia = uuid_from_time(timestamp_producto) timestamp_marketing = random_date(start, end) tag_marketing = random.choice(tags_marketing) batch = BatchStatement(BatchType.LOGGED) prepared = session.prepare( "INSERT INTO productos (codigo_referencia, nombre_producto, alta_producto, precio_producto, descripcion, url_imagen, categoria, nombre_categoria)" + " VALUES (?, ?, ?, " + "{:0.2f}".format(precio_producto) + ", ?, ?, ?, ?)") batch.add(prepared, (codigo_referencia, nombre_producto, alta_producto, descripcion, url_imagen, categoria, nombre_categoria)) prepared = session.prepare( "INSERT INTO productos_por_marketing " + "(codigo_referencia, timestamp_marketing, tag_marketing, nombre_producto, " + " precio_producto, url_imagen) VALUES (?, ?, ?, ?, " +
def handle(self, **options): print('Running syncdb for Cassandra') sync_cassandra.Command().execute(**options) spinner = cycle('|/-\\') print('Creating 1000 random users') users = [] user_ids = [] for i in range(10**3): print('\r{} {}'.format(next(spinner), i), end='') user = UserModel(name=random_string(title=True)) user.save() users.append(user) user_ids.append(user.id) print('\r ', end='\r') print('Creating following relationships between these users') for i, user in enumerate(users): print('\r{} {}'.format(next(spinner), i), end='') followers = random.sample(user_ids, random.randrange(50)) user.following = [uuid for uuid in followers if user.id != uuid] user.save() print('\r ', end='\r') print('Creating 100k random feed entries') random_dates = islice(random_datetime_generator(), 10**4) feedids = [uuid_from_time(t) for t in random_dates] for i, feedid in enumerate(feedids): print('\r{} {}'.format(next(spinner), i), end='') entry = FeedEntryModel(userid=random.choice(user_ids), id=feedid, comment_count=random.randrange(10)) entry.save() print('\r ', end='\r') print('Creating 5000 random inbox entries') types = (CommentedInboxEntryModel, LikeInboxEntryModel, NewFollowerInboxEntryModel) random_dates = islice(random_datetime_generator(), 5000) inboxids = map(uuid_from_time, random_dates) for i, inboxid in enumerate(inboxids): print('\r{} {}'.format(next(spinner), i), end='') inboxtype = random.choice(types) fields = { 'userid': random.choice(user_ids), 'id': inboxid, 'feedentryid': random.choice(feedids), 'comment_text': ' '.join( [random_string() for _ in range(random.randrange(3, 10))]), 'likerid': random.choice(user_ids), 'followerid': random.choice(user_ids), } entry = inboxtype(**fields) entry.save() print('\r ', end='\r') print('Creating 1000 random bundles') random_dates = islice(random_datetime_generator(), 1000) bundleids = map(uuid_from_time, random_dates) for i, bundleid in enumerate(bundleids): print('\r{} {}'.format(next(spinner), i), end='') entrycount = random.randrange(2, 10) # pick entrycount unique feedids, not to be used again feedids, feedentries = feedids[:-entrycount], feedids[-entrycount:] entry = BundleEntryModel(userid=random.choice(user_ids), id=bundleid, comment_count=random.randrange(10), entry_ids=feedentries) entry.save() print('\r ', end='\r')
def timeuuid_now(): return uuid_from_time(datetime.datetime.now())
def parse_indigo_log_file(self, log_file): self.cassandra_client.connect(["s000.blurdev.com"]) cassandra_session = self.cassandra_client.session gzip_file_handler = gzip.open(log_file) line_counter = 0 try: linestr = gzip_file_handler.readline() pstmt = cassandra_session.prepare( "INSERT INTO device_logs.log_entry(id,deviceId,eventDatetime,api,appid,userid,resultCode,latency,service,method)VALUES(?,?,?,?,?,?,?,?,?,?)" ) batch_statement = BatchStatement() while linestr: # 2016-01-04 03:00:00,472 +0000 [0:0:0:0:0:0:0:1] INFO [qtp389572888-163610] com.motorola.blur.cloudsvc.service.CloudService#internalCrossZoneApiCall(1237) - [CloudService.Report.RemoteZone]: # api=/v1/dp/validatesession url=https://api-sg.svcmot.com/v1/dp/validatesession.json?_remotecall=1&_indigo_zone=CN&authtoken=0-fa644269f5406c77fb0143a35a9d265a1031705043&deviceid=1288446770950721536 # result=400 time=599 # -----use this one. # 2016-01-04 03:59:59,293 +0000 [0:0:0:0:0:0:0:1] INFO [qtp389572888-163690] com.motorola.blur.cloudsvc.service.CloudService#invoke(579) - [CloudService.Report.API]: # api=/v1/checkinuploader/upload appid=YDYWOLQB1NM35HHYPKOZW3V3Z33TC85I userid=null deviceid=1342508016933724160 status=200 time=1170 method=POST service=ccs_uploader # URI=/v1/checkinuploader/upload.pb querystring:deviceid=1342508016933724160&appId=YDYWOLQB1NM35HHYPKOZW3V3Z33TC85I&geolocation=China-East&geocheckintimestamp=1451879998028 # print linestr if linestr.count("CloudService.Report.API") > 0: log_fileds = linestr.split(" ") # print len(log_fileds) # print log_fileds if len(log_fileds) == 20: line_counter += 1 field_event_date = log_fileds[0] field_event_time = self.extract_time(log_fileds[1]) field_api = self.grep_value(log_fileds[10]) field_appid = self.grep_value(log_fileds[11]) field_userid = self.grep_value(log_fileds[12]) field_deviceid = self.grep_value(log_fileds[13]) field_result_code = self.get_int(self.grep_value(log_fileds[14])) field_latency = self.get_int(self.grep_value(log_fileds[15])) field_method = self.convert_method(self.grep_value(log_fileds[16])) field_service = self.grep_value(log_fileds[17]) # print field_event_date,field_event_time,field_api,field_appid,field_userid,field_deviceid,field_result_code,field_latency,field_method,field_service edt = self.to_datetime(field_event_date, field_event_time) batch_statement.add( pstmt.bind( ( util.uuid_from_time(edt), field_deviceid, edt, field_api, field_appid, field_userid, field_result_code, field_latency, field_service, field_method, ) ) ) if line_counter % 6000 == 0: cassandra_session.execute(batch_statement) batch_statement = BatchStatement() linestr = gzip_file_handler.readline() if line_counter % 6000 != 0: cassandra_session.execute(batch_statement) except BaseException, e: print e
def create_race(length, description, pet_category_name): dt = datetime.utcnow() uuid = uuid_from_time(dt) # TODO this is loading all pets ... random number?? race_pets = PetRaceCassandraDataStore.get_pets_by_category_name(pet_category_name) pet_c = PetRaceCassandraDataStore.get_pet_category_by_name(pet_category_name) participants = {} pet_ids = [] for p in race_pets: pet_ids.append(str(p["petId"])) p_id = uuid_from_time(datetime.utcnow()) participant = { 'raceParticipantId': str(p_id), 'petId': str(p["petId"]), 'raceId': str(uuid), 'petName': p["name"], 'petCategoryName': pet_c['name'], 'petCategoryId': str(pet_c['petCategoryId']), 'startTime': dt, 'endTime': None, 'finished': False, 'finished_position': None, 'current_distance': 0 } participants[str(p_id)] = participant RaceParticipant.create( raceParticipantId=p_id, petId=p["petId"], raceId=uuid, petName=p["name"], petCategoryName=pet_c['name'], petCategoryId=pet_c['petCategoryId'], startTime=dt ) PetRaceCassandraDataStore.increment_counter_by_name('RaceParticipant') saved_race = { 'raceId': str(uuid), 'numOfPets': len(race_pets), 'length': length, 'description': description, 'petCategoryId': str(pet_c['petCategoryId']), 'petCategoryName': pet_c['name'], 'startTime': dt, 'racersIds': pet_ids, 'baseSpeed': pet_c['speed'] } Race.create( raceId=uuid, numOfPets=len(race_pets), length=length, description=description, petCategoryId=pet_c['petCategoryId'], petCategoryName=pet_c['name'], startTime=dt, racersIds=pet_ids, baseSpeed=pet_c['speed'] ) PetRaceCassandraDataStore.increment_counter_by_name('Race') # self.logger.debug("race created") # self.logger.debug("race created: %s", saved_race) # self.logger.debug("race created: %s", participants) return saved_race, participants
def cassandra_insert_patentes(nombre_patente, descripcion, fec_presentacion, id_pais, listaareas, listainventores, listacolaboradores, idmasivo=None): #FIJO EN TODAS VAN LA LISTA DE MAPAS DE LOS COLABORADORES..ARMEMOLA colaboradores = crear_mapa_colaboradores(listacolaboradores) print("##############--->:: ", colaboradores) inventores = crear_mapa_inventores(listainventores) print("##############--->:: ", inventores) areas = cassandra_get_nombre_areasv2(listaareas) print("##############--->:: ", areas) myuuid = None if idmasivo == None: myuuid = uuid_from_time(time.time()) else: myuuid = idmasivo #print('') print("------->MYUUID:::", myuuid) id_invento = str(myuuid) #VOY A INGRESAR POR PAIS... #NOMBRE DEL PAIS>> nombre_pais = obtener_nombre_pais(id_pais) querypais = SimpleStatement( "INSERT INTO cpm.inventos_por_pais(id_invento,id_pais,nombre_pais,nombre,fec_presentacion,inventores,colaboradores,descripcion,area)values(%s,%s,%s,%s,%s,%s,%s,%s,%s)", consistency_level=ConsistencyLevel.QUORUM) cluster = Cluster(['master'], protocol_version=3) session = cluster.connect() session.execute( querypais, (id_invento, id_pais, nombre_pais, nombre_patente, fec_presentacion, inventores, colaboradores, descripcion, areas)) #VOY A INGRESAR POR inventor for idinv in listainventores: infoinventor = cassandra_get_inventor_por_id(idinv) for info in infoinventor: querypais = SimpleStatement( "INSERT INTO cpm.inventos_por_inventor(nombre_inventor,id_invento,id_inventor,nacionalidad,sexo,fec_nac,nombre,fec_presentacion,descripcion,area,colaboradores,pais,id_pais)values(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)", consistency_level=ConsistencyLevel.QUORUM) cluster = Cluster(['master'], protocol_version=3) session = cluster.connect() session.execute( querypais, (info.nombre, id_invento, idinv, info.pais, "F", "1996-01-01", nombre_patente, fec_presentacion, descripcion, areas, colaboradores, nombre_pais, id_pais)) break #VOY A INGRESAR POR AREA for idarea in listaareas: nombre_area = cassandra_get_area_por_id(idarea) querypais = SimpleStatement( "INSERT INTO cpm.inventos_por_area(area,nombre_area,id_invento,inventores,colaboradores,nombre,fec_presentacion,descripcion,pais,id_pais)values(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)", consistency_level=ConsistencyLevel.QUORUM) cluster = Cluster(['master'], protocol_version=3) session = cluster.connect() session.execute(querypais, (idarea, nombre_area, id_invento, inventores, colaboradores, nombre_patente, fec_presentacion, descripcion, nombre_pais, id_pais)) return "Patente ingresada con exito!!!"
def test_timeuuid(self): uuid = uuid_from_time(datetime(2015, 1, 1)) self.read_write_test('timeuuid', uuid)
def generate_time_uuid(): return uuid_from_time(datetime.now())
for element in data: date = dateutil.parser.parse(element['source']['date']) date = time.mktime(date.timetuple()) seriesdates.append(date) for tag in element['source']['tags']: if tag not in series: series[tag] = [] series[tag].append(date) cluster = Cluster() session = cluster.connect('db_tsa') session.default_timeout = 3600 clientname = 'movi' #guardando en cassandra la serie principal series_name = clientname for series_event_time in seriesdates: new_uuid = util.uuid_from_time(int(float(series_event_time))) session.execute( "INSERT INTO time_series (name, event_time) VALUES (%s, %s)", (series_name, new_uuid)) #guardando las series de los tags for tag_name, tag_series in series.items(): series_name = clientname + '_' + tag_name for series_event_time in tag_series: new_uuid = util.uuid_from_time(int(float(series_event_time))) session.execute( "INSERT INTO time_series (name, event_time) VALUES (%s, %s)", (series_name, new_uuid))