OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Pare the groups module down to basics. Adjust dependent files so that a 

real groups module can even be implemented.
0.6.0-stable
Melanie Thielker 2008-10-21 22:54:31 +00:00
parent 6df1517b1f
commit f44742f75f
6 changed files with 101 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
OpenSim/Framework/LLGroup.cs → OpenSim/Framework/GroupData.cs
View File

@ -34,47 +34,24 @@ using System.Text;
namespace OpenSim.Framework namespace OpenSim.Framework
{ {
public class GroupData public class GroupMembershipData
{ {
public string ActiveGroupTitle; // Group base data
//
public UUID GroupID; public UUID GroupID;
public List<UUID> GroupMembers; public string GroupName;
public string groupName;
public uint groupPowers = (uint)(GroupPowers.AllowLandmark | GroupPowers.AllowSetHome);
public List<string> GroupTitles;
public bool AcceptNotices = true;
public bool AllowPublish = true; public bool AllowPublish = true;
public string Charter = "Cool Group Yeah!";
public int contribution = 0;
public UUID FounderID = UUID.Zero;
public int groupMembershipCost = 0;
public int groupRollsCount = 1;
public UUID GroupPicture = UUID.Zero;
public bool MaturePublish = true; public bool MaturePublish = true;
public UUID Charter = UUID.Zero;
public UUID FounderID = UUID.Zero;
public UUID GroupPicture = UUID.Zero;
public int MembershipFee = 0; public int MembershipFee = 0;
public bool OpenEnrollment = true; public bool OpenEnrollment = true;
public bool ShowInList = true;
public GroupData() // Per user data
{ //
GroupTitles = new List<string>(); public bool AcceptNotices = true;
GroupMembers = new List<UUID>(); public int Contribution = 0;
} public uint GroupPowers = 0;
public GroupPowers ActiveGroupPowers
{
set { groupPowers = (uint)value; }
get { return (GroupPowers)groupPowers; }
}
}
public class GroupList
{
public List<UUID> m_GroupList;
public GroupList()
{
m_GroupList = new List<UUID>();
}
} }
} }

2
OpenSim/Framework/IClientAPI.cs
View File

@ -845,7 +845,7 @@ namespace OpenSim.Framework
void SendAdminResponse(UUID Token, uint AdminLevel); void SendAdminResponse(UUID Token, uint AdminLevel);
void SendGroupMembership(GroupData[] GroupMembership); void SendGroupMembership(GroupMembershipData[] GroupMembership);
void SendGroupNameReply(UUID groupLLUID, string GroupName); void SendGroupNameReply(UUID groupLLUID, string GroupName);

8
OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
View File

@ -6632,7 +6632,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
OutPacket(respondPacket, ThrottleOutPacketType.Task); OutPacket(respondPacket, ThrottleOutPacketType.Task);
} }
public void SendGroupMembership(GroupData[] GroupMembership) public void SendGroupMembership(GroupMembershipData[] GroupMembership)
{ {
AgentGroupDataUpdatePacket Groupupdate = new AgentGroupDataUpdatePacket(); AgentGroupDataUpdatePacket Groupupdate = new AgentGroupDataUpdatePacket();
AgentGroupDataUpdatePacket.GroupDataBlock[] Groups = new AgentGroupDataUpdatePacket.GroupDataBlock[GroupMembership.Length]; AgentGroupDataUpdatePacket.GroupDataBlock[] Groups = new AgentGroupDataUpdatePacket.GroupDataBlock[GroupMembership.Length];
@ -6640,11 +6640,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
{ {
AgentGroupDataUpdatePacket.GroupDataBlock Group = new AgentGroupDataUpdatePacket.GroupDataBlock(); AgentGroupDataUpdatePacket.GroupDataBlock Group = new AgentGroupDataUpdatePacket.GroupDataBlock();
Group.AcceptNotices = GroupMembership[i].AcceptNotices; Group.AcceptNotices = GroupMembership[i].AcceptNotices;
Group.Contribution = GroupMembership[i].contribution; Group.Contribution = GroupMembership[i].Contribution;
Group.GroupID = GroupMembership[i].GroupID; Group.GroupID = GroupMembership[i].GroupID;
Group.GroupInsigniaID = GroupMembership[i].GroupPicture; Group.GroupInsigniaID = GroupMembership[i].GroupPicture;
Group.GroupName = Utils.StringToBytes(GroupMembership[i].groupName); Group.GroupName = Utils.StringToBytes(GroupMembership[i].GroupName);
Group.GroupPowers = GroupMembership[i].groupPowers; Group.GroupPowers = GroupMembership[i].GroupPowers;
Groups[i] = Group; Groups[i] = Group;
Groupupdate.GroupData = Groups; Groupupdate.GroupData = Groups;

209
OpenSim/Region/Environment/Modules/Avatar/Groups/GroupsModule.cs
View File

@ -39,15 +39,22 @@ namespace OpenSim.Region.Environment.Modules.Avatar.Groups
{ {
public class GroupsModule : IRegionModule public class GroupsModule : IRegionModule
{ {
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); private static readonly ILog m_log =
LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private Dictionary<UUID, GroupList> m_grouplistmap = new Dictionary<UUID, GroupList>(); private Dictionary<UUID, GroupMembershipData> m_GroupMap =
private Dictionary<UUID, GroupData> m_groupmap = new Dictionary<UUID, GroupData>(); new Dictionary<UUID, GroupMembershipData>();
private Dictionary<UUID, IClientAPI> m_iclientmap = new Dictionary<UUID, IClientAPI>();
private Dictionary<UUID, GroupData> m_groupUUIDGroup = new Dictionary<UUID, GroupData>();
private UUID opensimulatorGroupID = new UUID("00000000-68f9-1111-024e-222222111123");
private List<Scene> m_scene = new List<Scene>(); private Dictionary<UUID, IClientAPI> m_ClientMap =
new Dictionary<UUID, IClientAPI>();
private UUID opensimulatorGroupID =
new UUID("00000000-68f9-1111-024e-222222111123");
private List<Scene> m_SceneList = new List<Scene>();
private static GroupMembershipData osGroup =
new GroupMembershipData();
#region IRegionModule Members #region IRegionModule Members
@ -73,26 +80,27 @@ namespace OpenSim.Region.Environment.Modules.Avatar.Groups
m_log.Info("[GROUPS] Activated default groups module"); m_log.Info("[GROUPS] Activated default groups module");
lock (m_scene) lock (m_SceneList)
{ {
m_scene.Add(scene); if (!m_SceneList.Contains(scene))
{
if (m_SceneList.Count == 0)
{
osGroup.GroupID = opensimulatorGroupID;
osGroup.GroupName = "OpenSimulator Testing";
osGroup.GroupPowers =
(uint)(GroupPowers.AllowLandmark |
GroupPowers.AllowSetHome);
m_GroupMap[opensimulatorGroupID] = osGroup;
} }
m_SceneList.Add(scene);
}
}
scene.EventManager.OnNewClient += OnNewClient; scene.EventManager.OnNewClient += OnNewClient;
scene.EventManager.OnClientClosed += OnClientClosed; scene.EventManager.OnClientClosed += OnClientClosed;
scene.EventManager.OnGridInstantMessageToGroupsModule += OnGridInstantMessage; scene.EventManager.OnGridInstantMessageToGroupsModule +=
lock (m_groupUUIDGroup) OnGridInstantMessage;
{
GroupData OpenSimulatorGroup = new GroupData();
OpenSimulatorGroup.ActiveGroupTitle = "OpenSimulator Tester";
OpenSimulatorGroup.GroupID = opensimulatorGroupID;
OpenSimulatorGroup.groupName = "OpenSimulator Testing";
OpenSimulatorGroup.ActiveGroupPowers = GroupPowers.AllowSetHome;
OpenSimulatorGroup.GroupTitles.Add("OpenSimulator Tester");
if (!m_groupUUIDGroup.ContainsKey(opensimulatorGroupID))
m_groupUUIDGroup.Add(opensimulatorGroupID, OpenSimulatorGroup);
}
//scene.EventManager.
} }
public void PostInitialise() public void PostInitialise()
@ -102,21 +110,15 @@ namespace OpenSim.Region.Environment.Modules.Avatar.Groups
public void Close() public void Close()
{ {
m_log.Info("[GROUP]: Shutting down group module."); m_log.Info("[GROUP]: Shutting down group module.");
lock (m_iclientmap) lock (m_ClientMap)
{ {
m_iclientmap.Clear(); m_ClientMap.Clear();
} }
lock (m_groupmap) lock (m_GroupMap)
{ {
m_groupmap.Clear(); m_GroupMap.Clear();
} }
lock (m_grouplistmap)
{
m_grouplistmap.Clear();
}
GC.Collect();
} }
public string Name public string Name
@ -138,88 +140,42 @@ namespace OpenSim.Region.Environment.Modules.Avatar.Groups
client.OnInstantMessage += OnInstantMessage; client.OnInstantMessage += OnInstantMessage;
client.OnAgentDataUpdateRequest += OnAgentDataUpdateRequest; client.OnAgentDataUpdateRequest += OnAgentDataUpdateRequest;
client.OnUUIDGroupNameRequest += HandleUUIDGroupNameRequest; client.OnUUIDGroupNameRequest += HandleUUIDGroupNameRequest;
lock (m_iclientmap) lock (m_ClientMap)
{ {
if (!m_iclientmap.ContainsKey(client.AgentId)) if (!m_ClientMap.ContainsKey(client.AgentId))
{ {
m_iclientmap.Add(client.AgentId, client); m_ClientMap.Add(client.AgentId, client);
} }
} }
GroupData OpenSimulatorGroup = null;
lock (m_groupUUIDGroup)
{
OpenSimulatorGroup = m_groupUUIDGroup[opensimulatorGroupID];
if (!OpenSimulatorGroup.GroupMembers.Contains(client.AgentId))
{
OpenSimulatorGroup.GroupMembers.Add(client.AgentId);
m_groupUUIDGroup[opensimulatorGroupID] = OpenSimulatorGroup;
}
} m_log.Info("[GROUP]: Adding " + client.Name + " to " +
osGroup.GroupName + " ");
lock (m_groupmap) GroupMembershipData[] updateGroups = new GroupMembershipData[1];
{ updateGroups[0] = osGroup;
if (!m_groupmap.ContainsKey(client.AgentId))
{
m_groupmap.Add(client.AgentId, OpenSimulatorGroup);
}
}
GroupList testGroupList = new GroupList();
testGroupList.m_GroupList.Add(OpenSimulatorGroup.GroupID);
lock (m_grouplistmap)
{
if (!m_grouplistmap.ContainsKey(client.AgentId))
{
m_grouplistmap.Add(client.AgentId, testGroupList);
}
}
m_log.Info("[GROUP]: Adding " + client.Name + " to " + OpenSimulatorGroup.groupName + " ");
GroupData[] updateGroups = new GroupData[1];
updateGroups[0] = OpenSimulatorGroup;
client.SendGroupMembership(updateGroups); client.SendGroupMembership(updateGroups);
} }
private void OnAgentDataUpdateRequest(IClientAPI remoteClient, UUID AgentID, UUID SessionID) private void OnAgentDataUpdateRequest(IClientAPI remoteClient,
UUID AgentID, UUID SessionID)
{ {
// Adam, this is one of those impossible to refactor items without resorting to .Split hackery UUID ActiveGroupID;
string ActiveGroupName;
uint ActiveGroupPowers;
string firstname = remoteClient.FirstName; string firstname = remoteClient.FirstName;
string lastname = remoteClient.LastName; string lastname = remoteClient.LastName;
UUID ActiveGroupID = UUID.Zero;
uint ActiveGroupPowers = 0;
string ActiveGroupName = "OpenSimulator Tester";
string ActiveGroupTitle = "I IZ N0T"; string ActiveGroupTitle = "I IZ N0T";
bool foundUser = false; ActiveGroupID = osGroup.GroupID;
ActiveGroupName = osGroup.GroupName;
ActiveGroupPowers = osGroup.GroupPowers;
lock (m_iclientmap) remoteClient.SendAgentDataUpdate(AgentID, ActiveGroupID, firstname,
{ lastname, ActiveGroupPowers, ActiveGroupName,
if (m_iclientmap.ContainsKey(remoteClient.AgentId)) ActiveGroupTitle);
{
foundUser = true;
}
}
if (foundUser)
{
lock (m_groupmap)
{
if (m_groupmap.ContainsKey(remoteClient.AgentId))
{
GroupData grp = m_groupmap[remoteClient.AgentId];
if (grp != null)
{
ActiveGroupID = grp.GroupID;
ActiveGroupName = grp.groupName;
ActiveGroupPowers = grp.groupPowers;
ActiveGroupTitle = grp.ActiveGroupTitle;
}
remoteClient.SendAgentDataUpdate(AgentID, ActiveGroupID, firstname, lastname, ActiveGroupPowers, ActiveGroupName, ActiveGroupTitle);
}
}
}
} }
private void OnInstantMessage(IClientAPI client, UUID fromAgentID, private void OnInstantMessage(IClientAPI client, UUID fromAgentID,
@ -234,63 +190,54 @@ namespace OpenSim.Region.Environment.Modules.Avatar.Groups
private void OnGridInstantMessage(GridInstantMessage msg) private void OnGridInstantMessage(GridInstantMessage msg)
{ {
// Trigger the above event handler // Trigger the above event handler
OnInstantMessage(null, new UUID(msg.fromAgentID), new UUID(msg.fromAgentSession), OnInstantMessage(null, new UUID(msg.fromAgentID),
new UUID(msg.toAgentID), new UUID(msg.imSessionID), msg.timestamp, msg.fromAgentName, new UUID(msg.fromAgentSession),
msg.message, msg.dialog, msg.fromGroup, msg.offline, msg.ParentEstateID, new UUID(msg.toAgentID), new UUID(msg.imSessionID),
new Vector3(msg.Position.X, msg.Position.Y, msg.Position.Z), new UUID(msg.RegionID), msg.timestamp, msg.fromAgentName,
msg.message, msg.dialog, msg.fromGroup, msg.offline,
msg.ParentEstateID,
new Vector3(msg.Position.X, msg.Position.Y, msg.Position.Z),
new UUID(msg.RegionID),
msg.binaryBucket); msg.binaryBucket);
} }
private void HandleUUIDGroupNameRequest(UUID id,IClientAPI remote_client) private void HandleUUIDGroupNameRequest(UUID id,IClientAPI remote_client)
{ {
string groupnamereply = "Unknown"; string groupnamereply = "Unknown";
UUID groupUUID = UUID.Zero; UUID groupUUID = UUID.Zero;
lock (m_groupUUIDGroup) lock (m_GroupMap)
{ {
if (m_groupUUIDGroup.ContainsKey(id)) if (m_GroupMap.ContainsKey(id))
{ {
GroupData grp = m_groupUUIDGroup[id]; GroupMembershipData grp = m_GroupMap[id];
groupnamereply = grp.groupName; groupnamereply = grp.GroupName;
groupUUID = grp.GroupID; groupUUID = grp.GroupID;
} }
} }
remote_client.SendGroupNameReply(groupUUID, groupnamereply); remote_client.SendGroupNameReply(groupUUID, groupnamereply);
} }
private void OnClientClosed(UUID agentID) private void OnClientClosed(UUID agentID)
{ {
lock (m_iclientmap) lock (m_ClientMap)
{ {
if (m_iclientmap.ContainsKey(agentID)) if (m_ClientMap.ContainsKey(agentID))
{ {
IClientAPI cli = m_iclientmap[agentID]; IClientAPI cli = m_ClientMap[agentID];
if (cli != null) if (cli != null)
{ {
m_log.Info("[GROUP]: Removing all reference to groups for " + cli.Name); m_log.Info("[GROUP]: Removing all reference to groups "+
"for " + cli.Name);
} }
else else
{ {
m_log.Info("[GROUP]: Removing all reference to groups for " + agentID.ToString()); m_log.Info("[GROUP]: Removing all reference to groups "+
"for " + agentID.ToString());
}
m_ClientMap.Remove(agentID);
}
} }
m_iclientmap.Remove(agentID);
}
}
lock (m_groupmap)
{
if (m_groupmap.ContainsKey(agentID))
{
m_groupmap.Remove(agentID);
}
}
lock (m_grouplistmap)
{
if (m_grouplistmap.ContainsKey(agentID))
{
m_grouplistmap.Remove(agentID);
}
}
GC.Collect();
} }
} }
} }

2
OpenSim/Region/Environment/Modules/World/NPC/NPCAvatar.cs
View File

@ -109,7 +109,7 @@ namespace OpenSim.Region.Environment.Modules.World.NPC
} }
public void SendGroupMembership(GroupData[] GroupMembership) public void SendGroupMembership(GroupMembershipData[] GroupMembership)
{ {
} }

2
OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
View File

@ -667,7 +667,7 @@ namespace OpenSim.Region.Examples.SimpleModule
} }
public void SendGroupMembership(GroupData[] GroupMembership) public void SendGroupMembership(GroupMembershipData[] GroupMembership)
{ {
} }