private KwsAnpEventStatus HandleKwsCreatedEvent(AnpMsg msg)
{
KwsCredentials creds = m_kws.Cd.Credentials;
// Add the creator to the user list.
KwsUser user = new KwsUser();
user.UserID = msg.Elements[2].UInt32;
user.InvitationDate = msg.Elements[1].UInt64;
user.AdminName = msg.Elements[3].String;
user.EmailAddress = msg.Elements[4].String;
user.OrgName = msg.Elements[msg.Minor <= 2 ? 7 : 5].String;
user.AdminFlag = true;
user.ManagerFlag = true;
user.RegisterFlag = true;
m_kws.Cd.UserInfo.UserTree[user.UserID] = user;
// Update the workspace data.
if (msg.Minor <= 2)
{
creds.SecureFlag = true;
}
if (msg.Minor >= 3)
{
creds.KwsName = msg.Elements[6].String;
creds.Flags = msg.Elements[7].UInt32;
creds.KwmoAddress = msg.Elements[8].String;
}
m_kws.OnStateChange(WmStateChange.Permanent);
return KwsAnpEventStatus.Processed;
}
public KcdQuery(AnpMsg cmd, KcdQueryDelegate callback, WmKcd kcd, Workspace kws)
{
Debug.Assert(cmd.ID != 0);
Cmd = cmd;
Callback = callback;
Kcd = kcd;
Kws = kws;
}
public void HandleIncomingQuery(Object sender, EAnpIncomingQueryEventArgs args)
{
Tell("Incoming query received");
EAnpIncomingQuery q = args.Query;
if (!q.IsPending()) return;
q.OnCancellation += new EventHandler(OnQueryCancellation);
AnpMsg m = new AnpMsg();
m.Type = (uint)EAnpRes.OK;
q.Reply(m);
}
/// <summary>
/// Handle an ANP event.
/// </summary>
public KwsAnpEventStatus HandleAnpEvent(AnpMsg msg)
{
// Dispatch.
UInt32 type = msg.Type;
if (type == KAnp.KANP_EVT_KWS_CREATED) return HandleKwsCreatedEvent(msg);
else if (type == KAnp.KANP_EVT_KWS_INVITED) return HandleKwsInvitationEvent(msg);
else if (type == KAnp.KANP_EVT_KWS_USER_REGISTERED) return HandleUserRegisteredEvent(msg);
else if (type == KAnp.KANP_EVT_KWS_DELETED) return HandleKwsDeletedEvent();
else if (type == KAnp.KANP_EVT_KWS_LOG_OUT) return HandleKwsLogOut(msg);
else if (type == KAnp.KANP_EVT_KWS_PROP_CHANGE) return HandleKwsPropChange(msg);
else return KwsAnpEventStatus.Unprocessed;
}
public override KwsAnpEventStatus HandleAnpEvent(AnpMsg evt)
{
// Incoming chat message.
if (evt.Type == KAnp.KANP_EVT_CHAT_MSG)
{
UInt64 date = evt.Elements[1].UInt64;
UInt32 userID = evt.Elements[3].UInt32;
String userMsg = evt.Elements[4].String;
AnpMsg etEvt = Kws.MakePermEAnpEvent(EAnpEvt.ChatMsgReceived, date, userID);
etEvt.AddString(userMsg);
Kws.PostPermEAnpEvent(etEvt);
return KwsAnpEventStatus.Processed;
}
return KwsAnpEventStatus.Unprocessed;
}
public override void Parse(AnpMsg cmd)
{
int i = 0;
KwsID = cmd.Elements[i++].UInt64;
Task = (KwsTask)cmd.Elements[i++].UInt32;
}
public override void Parse(AnpMsg cmd)
{
int i = 0;
KwsId = cmd.Elements[i++].UInt64;
UserID = cmd.Elements[i++].UInt32;
RequestID = cmd.Elements[i++].UInt64;
}
/// <summary>
/// Handle the result of the commands.
/// </summary>
protected virtual void HandleCmdResult(AnpMsg res)
{
if (res.Type != KAnp.KANP_RES_OK) throw EAnpException.FromKAnpReply(res);
}
protected override void HandleCmdResult(AnpMsg res)
{
if (res.Type != KAnp.KANP_RES_KWS_INVITE_KWS) throw EAnpException.FromKAnpReply(res);
int i = 0;
Wleu = res.Elements[i++].String;
i++;
foreach (User u in UserList)
{
u.EmailID = res.Elements[i++].String;
u.Url = res.Elements[i++].String;
u.Error = res.Elements[i++].String;
}
}
public override void Parse(AnpMsg cmd)
{
int i = 0;
KwsId = cmd.Elements[i++].UInt64;
KcdSendEmailFlag = cmd.Elements[i++].UInt32 > 0;
InvitationMsg = cmd.Elements[i++].String;
UInt32 nbUser = cmd.Elements[i++].UInt32;
for (UInt32 j = 0; j < nbUser; j++)
{
User u = new User();
UserList.Add(u);
u.UserName = cmd.Elements[i++].String;
u.EmailAddress = cmd.Elements[i++].String;
u.KeyID = cmd.Elements[i++].UInt64;
u.OrgName = cmd.Elements[i++].String;
u.Pwd = cmd.Elements[i++].String;
}
}
public override void Parse(AnpMsg cmd)
{
int i = 0;
Creds.KwsName = cmd.Elements[i++].String;
Creds.Flags = cmd.Elements[i++].UInt32;
}
/// <summary>
/// Store the KAnp event specified with the status specified.
/// </summary>
public void StoreKAnpEvent(UInt64 kwsID, AnpMsg msg, KwsAnpEventStatus status)
{
try
{
DbCommand cmd = m_db.GetCmd("INSERT INTO kanp_events (kws_id, evt_id, evt_data, status) VALUES (?, ?, ?, ?);");
m_db.AddParamToCmd(cmd, kwsID);
m_db.AddParamToCmd(cmd, msg.ID);
m_db.AddParamToCmd(cmd, msg.ToByteArray(true));
m_db.AddParamToCmd(cmd, status);
cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
KBase.HandleException(ex, true);
}
}
/// <summary>
/// Create a new KCD ANP command message having the minor version and
/// type specified and a unique ID.
/// </summary>
public static AnpMsg NewKcdCmd(UInt32 minorVersion, UInt32 type)
{
AnpMsg msg = new AnpMsg();
msg.Major = KAnp.Major;
msg.Minor = minorVersion;
msg.Type = type;
msg.ID = WmKcdState.NextKcdCmdID++;
return msg;
}
/// <summary>
/// Dispatch an KCD event and update the state as needed.
/// </summary>
private void DispatchKcdEvent(AnpMsg msg)
{
// Dispatch the event to the appropriate handler.
KwsAnpEventStatus newStatus = DispatchAnpEventToHandler(msg);
// For quenching purposes we assume the event was processed.
WmSm.HandleKcdEventProcessed();
// If the ANP event has been processed, update its entry in the
// database and the catch up state as required.
if (newStatus == KwsAnpEventStatus.Processed)
{
if (msg.ID > 0)
{
Debug.Assert(m_ks.NbUnprocessedEvent > 0);
m_kws.UpdateKAnpEventStatusInDb(msg.ID, KwsAnpEventStatus.Processed);
m_ks.NbUnprocessedEvent--;
UpdateKcdEventUpToDateState();
m_kws.OnStateChange(WmStateChange.Permanent);
}
}
}
/// <summary>
/// Dispatch an ANP event to the appropriate handler.
/// </summary>
private KwsAnpEventStatus DispatchAnpEventToHandler(AnpMsg msg)
{
// If this event version is not supported, disable the workspace.
if (msg.Minor > KAnp.Minor)
{
RequestTaskSwitch(KwsTask.Stop, new EAnpExUpgradeKwm());
return KwsAnpEventStatus.Unprocessed;
}
// Dispatch to the appropriate handler.
try
{
UInt32 ns = KAnp.GetNsFromType(msg.Type);
KwsAnpEventStatus status = KwsAnpEventStatus.Unprocessed;
// Non-application-specific event.
if (ns == KAnp.KANP_NS_KWS)
{
status = m_kws.KcdEventHandler.HandleAnpEvent(msg);
}
// Application-specific event.
else
{
// Trivially process whiteboard events.
if (ns == KAnp.KANP_NS_WB) return KwsAnpEventStatus.Processed;
// Locate the application.
KwsApp app = m_kws.GetApp(ns);
if (app == null) throw new Exception("unknown application of type " + ns);
// Dispatch.
status = app.HandleAnpEvent(msg);
}
// Throw an exception if we cannot process an event that we
// should have been able to process.
if (status == KwsAnpEventStatus.Unprocessed && m_kws.IsOfflineCapable())
throw new Exception("failed to process KCD event");
return status;
}
catch (Exception ex)
{
HandleMiscFailure(ex);
return KwsAnpEventStatus.Unprocessed;
}
}
public override void Parse(AnpMsg cmd)
{
int i = 0;
KwsId = cmd.Elements[i++].UInt64;
ChannelID = cmd.Elements[i++].UInt32;
Msg = cmd.Elements[i++].String;
}
protected override void PrepareCmd(AnpMsg cmd)
{
cmd.Type = (uint)KAnp.KANP_CMD_CHAT_MSG;
cmd.AddUInt32(ChannelID);
cmd.AddString(Msg);
}
/// <summary>
/// Helper method for queries fetching an event.
/// </summary>
private AnpMsg GetEventFromQuery(String s)
{
Object res = m_db.GetCmd(s).ExecuteScalar();
if (res == null) return null;
AnpMsg m = new AnpMsg();
m.FromByteArray((byte[])res, true);
return m;
}
protected override void FormatSuccessReply(AnpMsg m)
{
m.Type = (uint)EAnpRes.CreateKws;
m.AddUInt64(Kws.InternalID);
}
/// <summary>
/// Fetch at most 'limit' EAnp events from the database, starting at
/// evtID.
/// </summary>
public List<AnpMsg> FetchEAnpEvents(UInt64 kwsID, UInt64 evtID, UInt32 limit)
{
String s = "SELECT evt_data FROM eanp_events WHERE kws_id = " + kwsID +
" AND evt_id > " + evtID + " ORDER BY evt_id LIMIT " + limit + ";";
List<AnpMsg> res = new List<AnpMsg>();
DbDataReader reader = m_db.GetCmd(s).ExecuteReader();
while (reader.Read())
{
AnpMsg m = new AnpMsg();
m.FromByteArray((byte[])reader.GetValue(0), true);
res.Add(m);
}
return res;
}
protected override void FormatSuccessReply(AnpMsg m)
{
m.Type = (uint)EAnpRes.InviteKws;
m.AddString(Wleu);
m.AddUInt32((uint)UserList.Count);
foreach (User u in UserList)
{
m.AddString(u.EmailAddress);
m.AddString(u.Url);
m.AddString(u.Error);
}
}
/// <summary>
/// Convert the EAnp elements specified to a EAnp exception. This is
/// used to deserialize EAnp exceptions stored in an ANP message.
/// </summary>
public static EAnpException FromEAnpMsg(AnpMsg m, int offset)
{
try
{
EAnpFailType t = (EAnpFailType)m.Elements[offset++].UInt32;
String s = m.Elements[offset++].String;
if (t == EAnpFailType.Generic) return new EAnpExGeneric(s);
else if (t == EAnpFailType.Cancelled) return new EAnpExCancelled();
else if (t == EAnpFailType.Interrupted) return new EAnpExInterrupted();
else if (t == EAnpFailType.Concurrent) return new EAnpExConcurrent();
else if (t == EAnpFailType.KcdConn) return new EAnpExKcdConn();
else if (t == EAnpFailType.EAnpConn) return new EAnpExEAnpConn();
else if (t == EAnpFailType.InvalidKpsConfig) return new EAnpExInvalidKpsConfig();
else if (t == EAnpFailType.InvalidKwsLoginPwd) return new EAnpExInvalidKwsLoginPwd();
else if (t == EAnpFailType.PermDenied) return new EAnpExPermDenied(s);
else if (t == EAnpFailType.QuotaExceeded)
{
EAnpQuotaType qt = (EAnpQuotaType)m.Elements[offset++].UInt32;
return new EAnpExQuotaExceeded(qt, s);
}
else if (t == EAnpFailType.UpgradeKwm) return new EAnpExUpgradeKwm();
else return new EAnpExGeneric("unmapped exception");
}
catch (Exception)
{
return new EAnpExGeneric("ill formated exception message");
}
}
protected override void PrepareCmd(AnpMsg cmd)
{
cmd.Type = (uint)KAnp.KANP_CMD_KWS_INVITE_KWS;
cmd.AddString(InvitationMsg);
cmd.AddUInt32((UInt32)UserList.Count);
foreach (User u in UserList)
{
cmd.AddString(u.UserName);
cmd.AddString(u.EmailAddress);
cmd.AddUInt64(u.KeyID);
cmd.AddString(u.OrgName);
cmd.AddString(u.Pwd);
cmd.AddUInt32(Convert.ToUInt32(KcdSendEmailFlag));
}
}
/// <summary>
/// Convert the KAnp elements specified to a EAnp exception.
/// </summary>
public static EAnpException FromKAnpFailure(AnpMsg m, int offset)
{
try
{
UInt32 t = m.Elements[offset++].UInt32;
String s = m.Elements[offset++].String;
if (t == KAnp.KANP_RES_FAIL_PERM_DENIED) return new EAnpExPermDenied(s);
else if (t == KAnp.KANP_RES_FAIL_FILE_QUOTA_EXCEEDED)
return new EAnpExQuotaExceeded(EAnpQuotaType.PerKwsFileQuota, s);
else if (t == KAnp.KANP_RES_FAIL_RESOURCE_QUOTA)
{
EAnpQuotaType qt = EAnpQuotaType.Generic;
UInt32 u = m.Elements[offset++].UInt32;
if (u == KAnp.KANP_RESOURCE_QUOTA_NO_SECURE) qt = EAnpQuotaType.SecureKws;
return new EAnpExQuotaExceeded(qt, s);
}
else return new EAnpExGeneric(s);
}
catch (Exception)
{
return new EAnpExGeneric("ill formated failure message");
}
}
/// <summary>
/// Prepare the command to send to the KCD.
/// </summary>
protected virtual void PrepareCmd(AnpMsg cmd)
{
}
/// <summary>
/// Convert the KAnp reply specified to a EAnp exception.
/// </summary>
public static EAnpException FromKAnpReply(AnpMsg m)
{
if (m.Type != KAnp.KANP_RES_FAIL) return new EAnpExGeneric("unexpected server response");
return FromKAnpFailure(m, 0);
}
protected override void PrepareCmd(AnpMsg cmd)
{
cmd.Type = (uint)KAnp.KANP_CMD_PB_ACCEPT_CHAT;
cmd.AddUInt64(RequestID);
cmd.AddUInt32(UserID);
cmd.AddUInt32(UserID);
}
/// <summary>
/// Add the content of this exception to the ANP message specified.
/// This is used to serialize an EAnp exception to an ANP message.
/// </summary>
public virtual void Serialize(AnpMsg m)
{
m.AddUInt32((UInt32)FailType);
m.AddString(Message);
}
public override void Parse(AnpMsg cmd)
{
int i = 0;
KwsID = cmd.Elements[i++].UInt64;
Pwd = cmd.Elements[i++].String;
}
public override void Serialize(AnpMsg m)
{
base.Serialize(m);
m.AddUInt32((uint)QuotaType);
}
