WebSVN – clockwerk-opensim – Blame – Rev 1 – /OpenSim/Region/CoreModules/Framework/UserManagement/UserManagementModule.cs

            m_log.DebugFormat("[USER MANAGEMENT MODULE]: Caching creators' data from {0} ({1} objects)...", s.RegionInfo.RegionName, s.GetEntities().Length);

142

s.ForEachSOG(delegate(SceneObjectGroup sog) { CacheCreators(sog); });

143

}

144

145

void EventManager_OnNewClient(IClientAPI client)

146

{

147

client.OnConnectionClosed += new Action<IClientAPI>(HandleConnectionClosed);

148

client.OnNameFromUUIDRequest += new UUIDNameRequest(HandleUUIDNameRequest);

149

client.OnAvatarPickerRequest += new AvatarPickerRequest(HandleAvatarPickerRequest);

150

}

151

152

void HandleConnectionClosed(IClientAPI client)

153

{

154

client.OnNameFromUUIDRequest -= new UUIDNameRequest(HandleUUIDNameRequest);

155

client.OnAvatarPickerRequest -= new AvatarPickerRequest(HandleAvatarPickerRequest);

156

}

157

158

void HandleUUIDNameRequest(UUID uuid, IClientAPI client)

159

{

160

// m_log.DebugFormat(

161

// "[USER MANAGEMENT MODULE]: Handling request for name binding of UUID {0} from {1}",

162

// uuid, remote_client.Name);

163

164

if (m_Scenes[0].LibraryService != null && (m_Scenes[0].LibraryService.LibraryRootFolder.Owner == uuid))

165

{

166

client.SendNameReply(uuid, "Mr", "OpenSim");

}

else

{

string[] names = new string[2];

171

if (TryGetUserNamesFromCache(uuid, names))

172

{

173

client.SendNameReply(uuid, names[0], names[1]);

return;

}

// Not found in cache, queue continuation

178

m_ServiceThrottle.Enqueue("name", uuid.ToString(), delegate

179

{

180

//m_log.DebugFormat("[YYY]: Name request {0}", uuid);

181

182

// As least upto September 2013, clients permanently cache UUID -> Name bindings. Some clients

183

// appear to clear this when the user asks it to clear the cache, but others may not.

184

//

185

// So to avoid clients

186

// (particularly Hypergrid clients) permanently binding "Unknown User" to a given UUID, we will

187

// instead drop the request entirely.

188

if (TryGetUserNames(uuid, names))

189

client.SendNameReply(uuid, names[0], names[1]);

190

// else

191

// m_log.DebugFormat(

192

// "[USER MANAGEMENT MODULE]: No bound name for {0} found, ignoring request from {1}",

193

// uuid, client.Name);

});

}

}

public void HandleAvatarPickerRequest(IClientAPI client, UUID avatarID, UUID RequestID, string query)

199

{

200

//EventManager.TriggerAvatarPickerRequest();

201

202

m_log.DebugFormat("[USER MANAGEMENT MODULE]: HandleAvatarPickerRequest for {0}", query);

203

204

List<UserData> users = GetUserData(query, 500, 1);

205

206

            AvatarPickerReplyPacket replyPacket = (AvatarPickerReplyPacket)PacketPool.Instance.GetPacket(PacketType.AvatarPickerReply);

207

// TODO: don't create new blocks if recycling an old packet

208

209

AvatarPickerReplyPacket.DataBlock[] searchData =

210

new AvatarPickerReplyPacket.DataBlock[users.Count];

211

AvatarPickerReplyPacket.AgentDataBlock agentData = new AvatarPickerReplyPacket.AgentDataBlock();

212

213

agentData.AgentID = avatarID;

214

agentData.QueryID = RequestID;

215

replyPacket.AgentData = agentData;

216

//byte[] bytes = new byte[AvatarResponses.Count*32];

217

218

int i = 0;

219

foreach (UserData item in users)

220

{

221

UUID translatedIDtem = item.Id;

222

searchData[i] = new AvatarPickerReplyPacket.DataBlock();

223

searchData[i].AvatarID = translatedIDtem;

224

searchData[i].FirstName = Utils.StringToBytes((string)item.FirstName);

225

searchData[i].LastName = Utils.StringToBytes((string)item.LastName);

226

i++;

227

}

228

if (users.Count == 0)

229

{

230

searchData = new AvatarPickerReplyPacket.DataBlock[0];

231

}

232

replyPacket.Data = searchData;

233

234

AvatarPickerReplyAgentDataArgs agent_data = new AvatarPickerReplyAgentDataArgs();

235

agent_data.AgentID = replyPacket.AgentData.AgentID;

236

agent_data.QueryID = replyPacket.AgentData.QueryID;

237

238

List<AvatarPickerReplyDataArgs> data_args = new List<AvatarPickerReplyDataArgs>();

239

for (i = 0; i < replyPacket.Data.Length; i++)

240

{

241

AvatarPickerReplyDataArgs data_arg = new AvatarPickerReplyDataArgs();

242

data_arg.AvatarID = replyPacket.Data[i].AvatarID;

243

data_arg.FirstName = replyPacket.Data[i].FirstName;

244

data_arg.LastName = replyPacket.Data[i].LastName;

245

data_args.Add(data_arg);

246

}

247

client.SendAvatarPickerReply(agent_data, data_args);

248

}

249

250

protected virtual void AddAdditionalUsers(string query, List<UserData> users)

{

}

#endregion Event Handlers

#region IPeople

public List<UserData> GetUserData(string query, int page_size, int page_number)

259

{

260

// search the user accounts service

261

            List<UserAccount> accs = m_Scenes[0].UserAccountService.GetUserAccounts(m_Scenes[0].RegionInfo.ScopeID, query);

262

263

List<UserData> users = new List<UserData>();

264

if (accs != null)

265

{

266

foreach (UserAccount acc in accs)

267

{

268

UserData ud = new UserData();

269

ud.FirstName = acc.FirstName;

270

ud.LastName = acc.LastName;

271

ud.Id = acc.PrincipalID;

users.Add(ud);

}

}

// search the local cache

277

lock (m_UserCache)

278

{

279

foreach (UserData data in m_UserCache.Values)

280

{

281

if (data.Id != UUID.Zero &&

282

users.Find(delegate(UserData d) { return d.Id == data.Id; }) == null &&

283

                        (data.FirstName.ToLower().StartsWith(query.ToLower()) || data.LastName.ToLower().StartsWith(query.ToLower())))

users.Add(data);

}

}

AddAdditionalUsers(query, users);

return users;

}

#endregion IPeople

private void CacheCreators(SceneObjectGroup sog)

297

{

298

            //m_log.DebugFormat("[USER MANAGEMENT MODULE]: processing {0} {1}; {2}", sog.RootPart.Name, sog.RootPart.CreatorData, sog.RootPart.CreatorIdentification);

299

AddUser(sog.RootPart.CreatorID, sog.RootPart.CreatorData);

300

301

foreach (SceneObjectPart sop in sog.Parts)

302

{

303

AddUser(sop.CreatorID, sop.CreatorData);

304

foreach (TaskInventoryItem item in sop.TaskInventory.Values)

305

AddUser(item.CreatorID, item.CreatorData);

}

}

/// <summary>

///

/// </summary>

/// <param name="uuid"></param>

313

/// <param name="names">Caller please provide a properly instantiated array for names, string[2]</param>

314

/// <returns></returns>

315

private bool TryGetUserNames(UUID uuid, string[] names)

316

{

317

if (names == null)

318

names = new string[2];

319

320

if (TryGetUserNamesFromCache(uuid, names))

321

return true;

322

323

if (TryGetUserNamesFromServices(uuid, names))

return true;

return false;

}

private bool TryGetUserNamesFromCache(UUID uuid, string[] names)

{

lock (m_UserCache)

{

if (m_UserCache.ContainsKey(uuid))

334

{

335

names[0] = m_UserCache[uuid].FirstName;

336

names[1] = m_UserCache[uuid].LastName;

return true;

}

}

return false;

}

/// <summary>

/// Try to get the names bound to the given uuid, from the services.

347

/// </summary>

348

/// <returns>True if the name was found, false if not.</returns>

349

/// <param name='uuid'></param>

350

        /// <param name='names'>The array of names if found.  If not found, then names[0] = "Unknown" and names[1] = "User"</param>

351

private bool TryGetUserNamesFromServices(UUID uuid, string[] names)

352

{

353

UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(UUID.Zero, uuid);

354

355

if (account != null)

356

{

357

names[0] = account.FirstName;

358

names[1] = account.LastName;

359

360

UserData user = new UserData();

361

user.FirstName = account.FirstName;

362

user.LastName = account.LastName;

363

364

lock (m_UserCache)

365

m_UserCache[uuid] = user;

return true;

}

else

{

// Let's try the GridUser service

372

GridUserInfo uInfo = m_Scenes[0].GridUserService.GetGridUserInfo(uuid.ToString());

373

if (uInfo != null)

374

{

375

string url, first, last, tmp;

376

UUID u;

377

if (Util.ParseUniversalUserIdentifier(uInfo.UserID, out u, out url, out first, out last, out tmp))

378

{

379

AddUser(uuid, first, last, url);

380

381

if (m_UserCache.ContainsKey(uuid))

382

{

383

names[0] = m_UserCache[uuid].FirstName;

384

names[1] = m_UserCache[uuid].LastName;

return true;

}

}

else

m_log.DebugFormat("[USER MANAGEMENT MODULE]: Unable to parse UUI {0}", uInfo.UserID);

}

else

{

m_log.DebugFormat("[USER MANAGEMENT MODULE]: No grid user found for {0}", uuid);

395

}

396

397

names[0] = "Unknown";

398

names[1] = "UserUMMTGUN9";

return false;

}

}

#region IUserManagement

405

406

public UUID GetUserIdByName(string name)

407

{

408

string[] parts = name.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);

409

if (parts.Length < 2)

410

throw new Exception("Name must have 2 components");

411

412

return GetUserIdByName(parts[0], parts[1]);

413

}

414

415

public UUID GetUserIdByName(string firstName, string lastName)

416

{

417

// TODO: Optimize for reverse lookup if this gets used by non-console commands.

418

lock (m_UserCache)

419

{

420

foreach (UserData user in m_UserCache.Values)

421

{

422

if (user.FirstName == firstName && user.LastName == lastName)

return user.Id;

}

}

UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(UUID.Zero, firstName, lastName);

428

429

if (account != null)

430

return account.PrincipalID;

return UUID.Zero;

}

public string GetUserName(UUID uuid)

436

{

437

string[] names = new string[2];

438

TryGetUserNames(uuid, names);

439

440

return names[0] + " " + names[1];

}

public string GetUserHomeURL(UUID userID)

{

lock (m_UserCache)

{

if (m_UserCache.ContainsKey(userID))

449

return m_UserCache[userID].HomeURL;

450

}

451

452

return string.Empty;

453

}

454

455

public string GetUserServerURL(UUID userID, string serverType)

{

UserData userdata;

lock (m_UserCache)

m_UserCache.TryGetValue(userID, out userdata);

460

461

if (userdata != null)

462

{

463

// m_log.DebugFormat("[USER MANAGEMENT MODULE]: Requested url type {0} for {1}", serverType, userID);

464

465

                if (userdata.ServerURLs != null && userdata.ServerURLs.ContainsKey(serverType) && userdata.ServerURLs[serverType] != null)

466

{

467

return userdata.ServerURLs[serverType].ToString();

468

}

469

470

if (!string.IsNullOrEmpty(userdata.HomeURL))

471

{

472

//m_log.DebugFormat(

473

// "[USER MANAGEMENT MODULE]: Did not find url type {0} so requesting urls from '{1}' for {2}",

474

// serverType, userdata.HomeURL, userID);

475

476

UserAgentServiceConnector uConn = new UserAgentServiceConnector(userdata.HomeURL);

477

try

478

{

479

userdata.ServerURLs = uConn.GetServerURLs(userID);

480

}

481

catch (Exception e)

482

{

483

m_log.Debug("[USER MANAGEMENT MODULE]: GetServerURLs call failed ", e);

484

userdata.ServerURLs = new Dictionary<string, object>();

485

}

486

487

                    if (userdata.ServerURLs != null && userdata.ServerURLs.ContainsKey(serverType) && userdata.ServerURLs[serverType] != null)

488

return userdata.ServerURLs[serverType].ToString();

}

}

return string.Empty;

493

}

494

495

public string GetUserUUI(UUID userID)

{

UserData ud;

lock (m_UserCache)

m_UserCache.TryGetValue(userID, out ud);

500

501

if (ud == null) // It's not in the cache

502

{

503

string[] names = new string[2];

504

// This will pull the data from either UserAccounts or GridUser

505

// and stick it into the cache

506

TryGetUserNamesFromServices(userID, names);

507

lock (m_UserCache)

508

m_UserCache.TryGetValue(userID, out ud);

}

if (ud != null)

{

string homeURL = ud.HomeURL;

514

string first = ud.FirstName, last = ud.LastName;

515

if (ud.LastName.StartsWith("@"))

516

{

517

string[] parts = ud.FirstName.Split('.');

518

if (parts.Length >= 2)

{

first = parts[0];

last = parts[1];

}

return userID + ";" + homeURL + ";" + first + " " + last;

}

}

return userID.ToString();

528

}

529

530

public void AddUser(UUID uuid, string first, string last)

{

lock (m_UserCache)

{

if (m_UserCache.ContainsKey(uuid))

return;

}

UserData user = new UserData();

539

user.Id = uuid;

540

user.FirstName = first;

541

user.LastName = last;

542

543

AddUserInternal(user);

544

}

545

546

public void AddUser(UUID uuid, string first, string last, string homeURL)

547

{

548

            //m_log.DebugFormat("[USER MANAGEMENT MODULE]: Adding user with id {0}, first {1}, last {2}, url {3}", uuid, first, last, homeURL);

549

if (homeURL == string.Empty)

550

return;

551

552

AddUser(uuid, homeURL + ";" + first + " " + last);

553

}

554

555

public void AddUser(UUID id, string creatorData)

556

{

557

//m_log.DebugFormat("[USER MANAGEMENT MODULE]: Adding user with id {0}, creatorData {1}", id, creatorData);

UserData oldUser;

lock (m_UserCache)

m_UserCache.TryGetValue(id, out oldUser);

562

563

if (oldUser != null)

564

{

565

if (string.IsNullOrEmpty(creatorData))

566

{

567

//ignore updates without creator data

return;

}

//try update unknown users, but don't update anyone else

572

if (oldUser.FirstName == "Unknown" && !creatorData.Contains("Unknown"))

573

{

574

lock (m_UserCache)

575

m_UserCache.Remove(id);

576

                    m_log.DebugFormat("[USER MANAGEMENT MODULE]: Re-adding user with id {0}, creatorData [{1}] and old HomeURL {2}", id, creatorData, oldUser.HomeURL);

}

else

{

//we have already a valid user within the cache

return;

}

}

UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, id);

586

587

if (account != null)

588

{

589

AddUser(id, account.FirstName, account.LastName);

}

else

{

UserData user = new UserData();

594

user.Id = id;

595

596

if (!string.IsNullOrEmpty(creatorData))

597

{

598

//creatorData = <endpoint>;<name>

599

600

string[] parts = creatorData.Split(';');

601

if (parts.Length >= 1)

602

{

603

user.HomeURL = parts[0];

604

try

605

{

606

Uri uri = new Uri(parts[0]);

607

user.LastName = "@" + uri.Authority;

608

}

609

catch (UriFormatException)

610

{

611

m_log.DebugFormat("[SCENE]: Unable to parse Uri {0}", parts[0]);

612

user.LastName = "@unknown";

}

}

if (parts.Length >= 2)

617

user.FirstName = parts[1].Replace(' ', '.');

}

else

{

// Temporarily add unknown user entries of this type into the cache so that we can distinguish

622

// this source from other recent (hopefully resolved) bugs that fail to retrieve a user name binding

623

// TODO: Can be removed when GUN* unknown users have definitely dropped significantly or

624

// disappeared.

625

user.FirstName = "Unknown";

626

user.LastName = "UserUMMAU4";

627

}

628

629

AddUserInternal(user);

}

}

void AddUserInternal(UserData user)

634

{

635

lock (m_UserCache)

636

m_UserCache[user.Id] = user;

637

638

//m_log.DebugFormat(

639

// "[USER MANAGEMENT MODULE]: Added user {0} {1} {2} {3}",

640

// user.Id, user.FirstName, user.LastName, user.HomeURL);

641

}

642

643

public bool IsLocalGridUser(UUID uuid)

644

{

645

UserAccount account = m_Scenes[0].UserAccountService.GetUserAccount(m_Scenes[0].RegionInfo.ScopeID, uuid);

646

if (account == null || (account != null && !account.LocalToGrid))

return false;

return true;

}

#endregion IUserManagement

653

654

protected void Init()

655

{

656

AddUser(UUID.Zero, "Unknown", "User");

657

RegisterConsoleCmds();

658

}

659

660

protected void RegisterConsoleCmds()

661

{

662

MainConsole.Instance.Commands.AddCommand("Users", true,

663

"show name",

664

"show name <uuid>",

665

"Show the bindings between a single user UUID and a user name",

String.Empty,

HandleShowUser);

MainConsole.Instance.Commands.AddCommand("Users", true,

670

"show names",

671

"show names",

672

"Show the bindings between user UUIDs and user names",

String.Empty,

HandleShowUsers);

}

private void HandleShowUser(string module, string[] cmd)

678

{

679

if (cmd.Length < 3)

680

{

681

MainConsole.Instance.OutputFormat("Usage: show name <uuid>");

return;

}

UUID userId;

if (!ConsoleUtil.TryParseConsoleUuid(MainConsole.Instance, cmd[2], out userId))

return;

UserData ud;

lock (m_UserCache)

{

if (!m_UserCache.TryGetValue(userId, out ud))

694

{

695

MainConsole.Instance.OutputFormat("No name known for user with id {0}", userId);

return;

}

}

ConsoleDisplayTable cdt = new ConsoleDisplayTable();

701

cdt.AddColumn("UUID", 36);

702

cdt.AddColumn("Name", 30);

703

cdt.AddColumn("HomeURL", 40);

704

cdt.AddRow(userId, string.Format("{0} {1}", ud.FirstName, ud.LastName), ud.HomeURL);

705

706

MainConsole.Instance.Output(cdt.ToString());

707

}

708

709

private void HandleShowUsers(string module, string[] cmd)

710

{

711

ConsoleDisplayTable cdt = new ConsoleDisplayTable();

712

cdt.AddColumn("UUID", 36);

713

cdt.AddColumn("Name", 30);

714

cdt.AddColumn("HomeURL", 40);

lock (m_UserCache)

{

foreach (KeyValuePair<UUID, UserData> kvp in m_UserCache)

719

                    cdt.AddRow(kvp.Key, string.Format("{0} {1}", kvp.Value.FirstName, kvp.Value.LastName), kvp.Value.HomeURL);

720

}

721

722

MainConsole.Instance.Output(cdt.ToString());

}

}

}

clockwerk-opensim – Blame information for rev 1