static void
fetch_uri (Sess *sess, Sess_Private_Data *priv, Call_Private_Data *cpriv,
const char *uri, size_t uri_len)
{
struct uri_list *el;
int is_relative;
size_t len;
char *dst;
if (strchr (uri, ':'))
{
len = strlen (param.server);
if (strncmp (uri, "http://", 7) == 0
&& strncmp (uri + 7, param.server, len) == 0
&& uri[7 + len] == '/')
{
uri += 7 + len;
uri_len -= 7 + len;
}
else
{
/* Eventually, we may want to create new sessions on the fly,
but for now, we simply punt on non-absolute URIs */
if (verbose > 1)
fprintf (stderr, "%s: ignoring absolute URI `%s'\n",
prog_name, uri);
return;
}
}
is_relative = (uri[0] != '/');
/* enqueue the new uri: */
len = uri_len;
if (is_relative)
len += prefix_len;
el = malloc (sizeof (*el) + len);
if (!el)
panic ("%s.fetch_uri: out of memory!\n", prog_name);
el->uri_len = len;
dst = el->uri;
if (is_relative)
{
memcpy (el->uri, prefix, prefix_len);
dst += prefix_len;
}
memcpy (dst, uri, uri_len + 1);
el->next = priv->uri_list;
priv->uri_list = el;
issue_calls (sess, priv);
}
static void
user_think_time_expired(struct Timer *t, Any_Type arg) {
Sess *sess = arg.vp;
Sess_Private_Data *priv;
assert(object_is_sess(sess));
priv = SESS_PRIVATE_DATA (sess);
priv->timer = 0;
issue_calls(sess, priv);
}
/* Create a new session. */
static int
sess_create (Any_Type arg)
{
Sess *sess;
if (num_sessions_generated++ >= param.wsesspage.num_sessions)
return -1;
sess = sess_new ();
if (!sess)
return 1;
issue_calls (sess, SESS_PRIVATE_DATA (sess));
return 0;
}
static void
call_destroyed (Event_Type et, Object *obj, Any_Type regarg, Any_Type callarg)
{
Call_Private_Data *cpriv;
Sess_Private_Data *priv;
Any_Type arg;
Sess *sess;
Call *call;
assert (et == EV_CALL_DESTROYED && object_is_call (obj));
call = (Call *) obj;
cpriv = CALL_PRIVATE_DATA (call);
sess = session_get_sess_from_call (call);
priv = SESS_PRIVATE_DATA (sess);
if (cpriv->to_free)
{
free (cpriv->to_free);
cpriv->to_free = 0;
}
++priv->num_destroyed;
if (sess->failed)
return;
if (priv->uri_list)
/* there are some queued URI's which we may be able to issue now */
issue_calls (sess, priv);
else if (priv->num_destroyed >= priv->num_created)
{
/* we're done with this burst */
if (++priv->num_reqs_completed >= param.wsesspage.num_reqs)
/* we're done with this session */
sess_dec_ref (sess);
else
{
/* schedule the user-think-time timer */
priv->num_created = 0;
assert (!priv->timer);
arg.vp = sess;
priv->timer = timer_schedule (user_think_time_expired, arg,
param.wsesspage.think_time);
}
}
}
/* Create a new session. */
static int
sess_create (Any_Type arg)
{
Sess_Private_Data *priv;
Sess *sess;
if (num_sessions_generated++ >= param.wsess.num_sessions)
return -1;
sess = sess_new ();
if (!sess)
return 1;
priv = SESS_PRIVATE_DATA (sess);
priv->num_calls_target = param.burst_len;
issue_calls (sess, SESS_PRIVATE_DATA (sess));
return 0;
}
static void
call_destroyed (Event_Type et, Object *obj, Any_Type regarg, Any_Type callarg)
{
Any_Type arg;
Sess *sess;
Call *call;
Sess_Private_Data *priv;
assert (et == EV_CALL_DESTROYED && object_is_call (obj));
call = (Call *) obj;
sess = session_get_sess_from_call (call);
priv = SESS_PRIVATE_DATA (sess);
++priv->num_calls_destroyed;
if (priv->num_calls_destroyed >= param.wsess.num_calls)
{
/* we're done with this session */
if (!sess->failed)
sess_dec_ref (sess);
}
else if (priv->num_calls_in_this_burst < param.burst_len)
/* now that we received the reply to the first call in this burst,
create the remaining calls */
issue_calls (sess, priv);
else if (priv->num_calls_destroyed >= priv->num_calls_target)
{
/* we're done with this burst---schedule the user-think-time timer */
priv->num_calls_in_this_burst = 0;
priv->num_calls_target += param.burst_len;
assert (!priv->timer);
arg.vp = sess;
priv->timer = timer_schedule (user_think_time_expired, arg,
param.wsess.think_time);
}
}
