def add_vehicles_helper(sess, chunk, n):
owners = sess.query(User).filter_by(city=city).all()
vehicles = []
for i in range(chunk, n):
vehicle_type = MovRGenerator.generate_random_vehicle()
vehicles.append(Vehicle(id=MovRGenerator.generate_uuid(),
type=vehicle_type,
city=city,
current_location=datagen.address(),
owner_id=(random.choice(owners)).id,
status=MovRGenerator.get_vehicle_availability(),
ext=MovRGenerator.generate_vehicle_metadata(vehicle_type)))
sess.bulk_save_objects(vehicles)
def start_ride_helper(session, city, rider_id, vehicle_id):
vehicle = session.query(Vehicle).filter_by(
city=city, id=vehicle_id
) if self.multi_region else session.query(Vehicle).filter_by(
id=vehicle_id)
vehicle.update({'status': 'in_use'})
v = vehicle.first()
# get promo codes associated with this user's account
upcs = session.query(UserPromoCode).filter_by(
city=city, user_id=rider_id).all(
) if self.multi_region else session.query(
UserPromoCode).filter_by(user_id=rider_id).all()
# determine which codes are valid
for upc in upcs:
promo_code = session.query(PromoCode).filter_by(
code=upc.code).first()
if promo_code and promo_code.expiration_time > datetime.datetime.now(
):
code_to_update = session.query(UserPromoCode).filter_by(
city=city, user_id=rider_id,
code=upc.code) if self.multi_region else session.query(
UserPromoCode).filter_by(user_id=rider_id,
code=upc.code)
code_to_update.update({'usage_count': upc.usage_count + 1})
r = Ride(city=city,
id=MovRGenerator.generate_uuid(),
rider_id=rider_id,
vehicle_id=vehicle_id,
start_address=v.current_location)
session.add(r)
return {'city': r.city, 'id': r.id}
def end_ride_helper(session, city, ride_id):
ride = session.query(Ride).filter_by(city=city, id=ride_id).first()
v = session.query(Vehicle).filter_by(city=city, id=ride.vehicle_id).first()
ride.end_address = v.current_location
ride.revenue = MovRGenerator.generate_revenue()
ride.end_time = datetime.datetime.now()
v.status = "available"
def add_user_helper(session, city, name, address, credit_card_number):
u = User(city=city,
id=MovRGenerator.generate_uuid(),
name=name,
address=address,
credit_card=credit_card_number)
session.add(u)
return {'city': u.city, 'id': u.id}
def add_rides_helper(sess, chunk, n):
users = sess.query(User).filter_by(city=city).all()
vehicles = sess.query(Vehicle).filter_by(city=city).all()
rides = []
for i in range(chunk, min(chunk + chunk_size, num_rides)):
start_time = datetime.datetime.now() - datetime.timedelta(days=random.randint(0, 30))
rides.append(Ride(id=MovRGenerator.generate_uuid(),
city=city,
rider_id=random.choice(users).id,
vehicle_id=random.choice(vehicles).id,
start_time=start_time,
start_address=datagen.address(),
end_address=datagen.address(),
revenue=MovRGenerator.generate_revenue(),
end_time=start_time + datetime.timedelta(minutes=random.randint(0, 60))))
sess.bulk_save_objects(rides)
def add_users_helper(sess, chunk, n):
users = []
for i in range(chunk, n):
users.append(User(id=MovRGenerator.generate_uuid(),
city=city,
name=datagen.name(),
address=datagen.address(),
credit_card=datagen.credit_card_number()))
sess.bulk_save_objects(users)
def add_vehicle_helper(session, city, owner_id, current_location, type, vehicle_metadata, status):
vehicle_type = type
vehicle = Vehicle(id=MovRGenerator.generate_uuid(), type=vehicle_type,
city=city, owner_id=owner_id, current_location = current_location,
status=status,
ext=vehicle_metadata)
session.add(vehicle)
return {'city': vehicle.city, 'id': vehicle.id}
def end_ride_helper(session, city, ride_id):
ride = session.query(Ride).filter_by(id=ride_id)
r = ride.first()
vehicle = session.query(Vehicle).filter_by(id=r.vehicle_id)
vehicle.update({'status': 'available'})
v = vehicle.first()
ride.update({
'end_address': v.current_location,
'revenue': MovRGenerator.generate_revenue(),
'end_time': datetime.datetime.now()
})
def add_vehicle_location_histories_helper(sess, chunk, n):
rides = sess.query(Ride).filter_by(city=city).all()
histories = []
for i in range(chunk, min(chunk + chunk_size, num_histories)):
latlong = MovRGenerator.generate_random_latlong()
histories.append(
VehicleLocationHistory(city=city,
ride_id=random.choice(rides).id,
lat=latlong["lat"],
long=latlong["long"]))
sess.bulk_save_objects(histories)
def start_ride_helper(session, city, rider_id, vehicle_id):
v = session.query(Vehicle).filter_by(city=city, id=vehicle_id).first()
# get promo codes associated with this user's account
upcs = session.query(UserPromoCode).filter_by(city=city, user_id=rider_id).all()
# determine which codes are valid
for upc in upcs:
promo_code = session.query(PromoCode).filter_by(code = upc.code).first()
if promo_code and promo_code.expiration_time > datetime.datetime.now():
upc.usage_count+=1;
#@todo: do something with the code
r = Ride(city=city, vehicle_city=city, id=MovRGenerator.generate_uuid(),
rider_id=rider_id, vehicle_id=vehicle_id,
start_address=v.current_location)
session.add(r)
v.status = "in_use"
return {'city': r.city, 'id': r.id}
def simulate_movr_load(conn_string,
cities,
movr_objects,
active_rides,
read_percentage,
follower_reads,
connection_duration_in_seconds,
echo_sql=False):
datagen = Faker()
while True:
logging.debug(
"creating a new connection to %s, which will reset in %d seconds",
conn_string, connection_duration_in_seconds)
try:
with MovR(conn_string, echo=echo_sql) as movr:
timeout = time.time(
) + connection_duration_in_seconds #refresh connections so load can balance among cluster nodes even if the cluster size changes
while True:
if TERMINATE_GRACEFULLY:
logging.debug("Terminating thread.")
return
if time.time() > timeout:
break
active_city = random.choice(cities)
if random.random() < read_percentage:
# simulate user loading screen
start = time.time()
movr.get_vehicles(active_city, follower_reads, 25)
stats.add_latency_measurement("get vehicles",
time.time() - start)
else:
# every write tick, simulate the various vehicles updating their locations if they are being used for rides
for ride in active_rides[0:10]:
latlong = MovRGenerator.generate_random_latlong()
start = time.time()
movr.update_ride_location(ride['city'],
ride_id=ride['id'],
lat=latlong['lat'],
long=latlong['long'])
stats.add_latency_measurement(
ACTION_UPDATE_RIDE_LOC,
time.time() - start)
#do write operations randomly
if random.random() < .03:
# simulate a movr marketer creating a new promo code
start = time.time()
promo_code = movr.create_promo_code(
code="_".join(datagen.words(nb=3)) + "_" +
str(time.time()),
description=datagen.paragraph(),
expiration_time=datetime.datetime.now() +
datetime.timedelta(days=random.randint(0, 30)),
rules={
"type": "percent_discount",
"value": "10%"
})
stats.add_latency_measurement(
ACTION_NEW_CODE,
time.time() - start)
movr_objects["global"].get("promo_codes",
[]).append(promo_code)
elif random.random() < .1:
# simulate a user applying a promo code to her account
start = time.time()
movr.apply_promo_code(
active_city,
random.choice(movr_objects["local"]
[active_city]["users"])['id'],
random.choice(
movr_objects["global"]["promo_codes"]))
stats.add_latency_measurement(
ACTION_APPLY_CODE,
time.time() - start)
elif random.random() < .3:
# simulate new signup
start = time.time()
new_user = movr.add_user(
active_city, datagen.name(), datagen.address(),
datagen.credit_card_number())
stats.add_latency_measurement(
ACTION_NEW_USER,
time.time() - start)
movr_objects["local"][active_city]["users"].append(
new_user)
elif random.random() < .1:
# simulate a user adding a new vehicle to the population
start = time.time()
new_vehicle = movr.add_vehicle(
active_city,
owner_id=random.choice(
movr_objects["local"][active_city]
["users"])['id'],
type=MovRGenerator.generate_random_vehicle(),
vehicle_metadata=MovRGenerator.
generate_vehicle_metadata(type),
status=MovRGenerator.get_vehicle_availability(
),
current_location=datagen.address())
stats.add_latency_measurement(
ACTION_ADD_VEHICLE,
time.time() - start)
movr_objects["local"][active_city][
"vehicles"].append(new_vehicle)
elif random.random() < .5:
# simulate a user starting a ride
start = time.time()
ride = movr.start_ride(
active_city,
random.choice(movr_objects["local"]
[active_city]["users"])['id'],
random.choice(movr_objects["local"]
[active_city]["vehicles"])['id'])
stats.add_latency_measurement(
ACTION_START_RIDE,
time.time() - start)
active_rides.append(ride)
else:
if len(active_rides):
#simulate a ride ending
ride = active_rides.pop()
start = time.time()
movr.end_ride(ride['city'], ride['id'])
stats.add_latency_measurement(
ACTION_END_RIDE,
time.time() - start)
except DBAPIError:
logging.error("lost connection to the db. sleeping for 10 seconds")
time.sleep(10)
