public override void UnRegisterProtocol(BaseProtocol pProtocol)
{
var userList = SOManager["userList"];
var room = SOManager["room"];
lock (room)
{
base.UnRegisterProtocol(pProtocol);
if (OnlineClient.ContainsValue(pProtocol))
{
var clientId = OnlineClient.Single(x => x.Value == pProtocol).Key;
if (room["publisher1"] != null && room["publisher1"]["id"] == clientId) room.UnSet("publisher1");
if (room["publisher2"] != null && room["publisher2"]["id"] == clientId) room.UnSet("publisher2");
if (room["adminId"] != null && room["adminId"]["id"] == clientId)
{
room.UnSet("adminId");
room.UnSet("ppt");
room.UnSet("pptPageNum");
}
room.Track();
OnlineClient.Remove(clientId);
userList.UnSet(clientId);
userList.Track();
}
}
}
public static BaseProtocol CreateProtocolChain(List <ulong> chain, Variant parameters)
{
BaseProtocol pResult = null;
//1. Check and see if all the protocols are handled by a factory
if (chain.Any(x => !_factoriesByProtocolId.ContainsKey(x)))
{
Logger.FATAL("protocol not handled by anynone");
return(null);
}
//2. Spawn the protocols
foreach (var item in chain)
{
var pProtocol = _factoriesByProtocolId[item].SpawnProtocol(item, parameters);
if (pProtocol == null)
{
Logger.FATAL("Unable to spawn protocol {0} handled by factory {1}", item.TagToString(), _factoriesByProtocolId[item].Id);
pResult?.FarEndpoint.Dispose();
return(null);
}
if (pResult != null)
{
pResult.NearProtocol = pProtocol;
}
pResult = pProtocol;
}
return(pResult.NearEndpoint);
}
public void ResetFarProtocol()
{
if (_farProtocol != null)
{
_farProtocol._nearProtocol = null;
}
_farProtocol = null;
}
public virtual void Dispose()
{
if (Protocol != null) {
Protocol.IOHandler = null;
Protocol.EnqueueForDelete();
Protocol = null;
}
this.UnRegisterIOHandler();
}
public static void RegisterProtocol(this BaseProtocol pProtocol)
{
if (!ActiveProtocols.ContainsKey(pProtocol.Id) && !DeadProtocols.ContainsKey(pProtocol.Id))
{
ActiveProtocols[pProtocol.Id] = pProtocol;
if (pProtocol is IManage)
{
ManageProtocols.Add(pProtocol as IManage);
}
}
}
public Variant _Broadcast(BaseProtocol pFrom, Variant invoke)
{
var message = Variant.Get();
message[Defines.RM_INVOKE_FUNCTION] = (string)invoke[1];
var param = invoke.Clone();
param.RemoveAt(0);
param.RemoveAt(0);
message[Defines.RM_INVOKE_PARAMS] = param;
Broadcast(pFrom,message);
return null;
}
public static void UnRegisterProtocol(this BaseProtocol pProtocol)
{
//if (ActiveProtocols.ContainsKey(pProtocol.Id))
//{
// ActiveProtocols.Remove(pProtocol.Id);
//}
//else if (DeadProtocols.ContainsKey(pProtocol.Id))
//{
// DeadProtocols.Remove(pProtocol.Id);
//}
}
public Variant GetOverall(BaseProtocol pFrom, Variant invoke)
{
var result = new Variant();
result["serverMode"] = ClientApplicationManager.IsSlave?"slave":"master";
result["appList"] = new Variant(ClientApplicationManager.ApplicationByName.Keys.Select(x=>new Variant(x)).ToList());
result["memory"] = _memoryPerformanceCounter.NextValue();
result["cpu"] = _oPerformanceCounter.NextValue();
result["bytesSent"] = _bytesSent.Sum(x => x.NextValue());
result["bytesReceived"] = _bytesReceived.Sum(x => x.NextValue());
result["bytesTotal"] = _bytesTotal.Sum(x => x.NextValue());
return result;
}
public override bool OnConnect(BaseProtocol pFrom, Variant param)
{
_oPerformanceCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
var p = Process.GetCurrentProcess();
var allCounters = _networkPerformanceCatagory.GetInstanceNames()
.SelectMany(name => _networkPerformanceCatagory.GetCounters(name)).ToList();
_bytesReceived = allCounters.Where(counters => counters.CounterName == "Bytes Received/sec");
_bytesTotal = allCounters.Where(counters => counters.CounterName == "Bytes Total/sec");
_bytesSent= allCounters.Where(counters => counters.CounterName == "Bytes Sent/sec");
_memoryPerformanceCounter =
_dotnetMemoryPerformanceCatagory.GetCounters(
_dotnetMemoryPerformanceCatagory.GetInstanceNames()
.Single(x => x == p.ProcessName || x.StartsWith(p.Id.ToString())))
.Single(x => x.CounterName == "# Total committed Bytes");
return true;
}
public static void EnqueueForDelete(this BaseProtocol pProtocol)
{
if (pProtocol.NearProtocol == null)
{
pProtocol.Log().Info("Enqueue for delete for protocol {0}", pProtocol.ToString());
}
pProtocol.Application = null;
if (ActiveProtocols.ContainsKey(pProtocol.Id))
{
ActiveProtocols.Remove(pProtocol.Id);
}
if (!DeadProtocols.ContainsKey(pProtocol.Id))
{
DeadProtocols[pProtocol.Id] = pProtocol;
}
}
public Variant _CallClient(BaseProtocol pFrom, Variant invoke)
{
string clientId = invoke[1];
string functionName = invoke[2];
if (OnlineClient.ContainsKey(clientId))
{
invoke.RemoveAt(1);
invoke.RemoveAt(1);
CallClient(OnlineClient[clientId], functionName, invoke);
}
else if(!(pFrom is BaseClusterProtocol))
{
if (ClientApplicationManager.ClusterApplication != null)
ClientApplicationManager.ClusterApplication.GetProtocolHandler<BaseClusterAppProtocolHandler>().CallAppFunction(Id, "_CallClient", invoke);
}
return null;
}
public Variant GetAppInfo(BaseProtocol pFrom, Variant invoke)
{
var appName = invoke[1];
var app = ClientApplicationManager.ApplicationByName[appName];
var result = new Variant();
result["config"] = app.Configuration;
result["servicesInfo"] = app.GetServicesInfo();
result["connections"] = new Variant(ProtocolManager.ActiveProtocols.Values.Where(x => x.Application == app).Select(x => x.GetStackStats(new Variant(), Id)).ToList());
result["streams"] = new Variant(StreamsManager.StreamsByUniqueId.Select(x =>
{
var info = new Variant();
info["name"] = x.Value.Name + "#" + x.Value.UniqueId;
x.Value.GetStats(info, Id);
return info;
}).ToList());
//foreach (var baseAppProtocolHandler in app.AppProtocolHandlers)
//{
//}
return result;
}
public virtual void Dispose()
{
if (_farProtocol != null)
{
_farProtocol._nearProtocol = null;
if (DeleteFarProtocol)
{
_farProtocol.EnqueueForDelete();
}
_farProtocol = null;
}
if (_nearProtocol != null)
{
_nearProtocol._farProtocol = null;
if (DeleteNearProtocol)
{
_nearProtocol.EnqueueForDelete();
}
_nearProtocol = null;
}
this.UnRegisterProtocol();
}
public override bool OnConnect(BaseProtocol pFrom, Variant param)
{
string clientId = param[1];
var so = SOManager["userList"];
lock (so)
{
if (so.HasProperty(clientId) && OnlineClient.ContainsKey(clientId)) Disconnect(OnlineClient[clientId]);
so.Set(clientId, Variant.GetMap(new VariantMapHelper
{
{"id",clientId},
{"name",(string)param[2]},
{"hasCamera",(bool)param[3]},
{"hasMic",(bool)param[4]},
{"role",(int)param[5]},
{"handUp",false}
}));
OnlineClient[clientId] = pFrom;
}
if ((int)param[5] == 1)
{
so = SOManager["room"];
lock (so)
{
so.Set("adminId", clientId);
// so.Set("publisher1", Variant.GetMap(new VariantMapHelper
//{
// {"id",clientId},
// {"name",(string)param[2]},
//}));
}
}
return true;
}
public static bool SignalProtocolCreated(BaseProtocol protocol, Variant customParameters)
{
var application = ClientApplicationManager.FindAppByName(customParameters[Defines.CONF_APPLICATION_NAME]);
if (application == null)
{
Logger.FATAL("Application {0} not found",customParameters[Defines.CONF_APPLICATION_NAME]);
return false;
}
if (protocol == null)
{
Logger.FATAL("Connection failed:{0}", customParameters.ToString());
return application.OutboundConnectionFailed(customParameters);
}
protocol.Application = application;
var outboundRTMPProtocol = protocol as OutboundRTMPProtocol;
outboundRTMPProtocol.CustomParameters = customParameters;
return outboundRTMPProtocol.SignalInputData(0);
}
public abstract void Broadcast(BaseProtocol from,Variant invokeInfo);
public void Broadcast(BaseClientApplication app, BaseProtocol @from, Variant invokeInfo)
{
ClusterAppProtocolHandler.Broadcast(app.Id, from, invokeInfo);
}
public Variant _Test(BaseProtocol protocol,Variant param)
{
return param;
}
public InFileRTMPStream(BaseProtocol pProtocol, StreamsManager pStreamsManager, string name) : base(pProtocol, pStreamsManager, name)
{
base.ChunkSize = 4 * 1024 * 1024;
}
public static InFileRTMPStream GetInstance(BaseProtocol pRTMPProtocol, StreamsManager pStreamsManager,
Variant metadata)
{
metadata[META_RTMP_META,HTTP_HEADERS_SERVER]= HTTP_HEADERS_SERVER_US;
if (!File.Exists(metadata[META_SERVER_FULL_PATH])) {
WARN("File not found. fullPath: `{0}`",metadata[META_SERVER_FULL_PATH]);
return null;
}
InFileRTMPStream pResult = null;
switch ((string)metadata[META_MEDIA_TYPE])
{
case MEDIA_TYPE_FLV:
case MEDIA_TYPE_LIVE_OR_FLV:
case MEDIA_TYPE_MP3:
case MEDIA_TYPE_MP4:
case MEDIA_TYPE_M4A:
case MEDIA_TYPE_M4V:
case MEDIA_TYPE_MOV:
pResult = new InFileRTMPStream(pRTMPProtocol,
pStreamsManager,metadata[META_SERVER_FULL_PATH]);
break;
default:
FATAL("File type not supported yet. Metadata:\n{0}",
metadata);
break;
}
if (pResult != null) {
pResult.CompleteMetadata = metadata;
}
return pResult;
}
public IOutFileStream CreateOutFileStream(BaseProtocol protocol, IInStream instream, bool append)
{
var pOutFileStream = CreateOutFileStream(protocol, instream.Name,null, append);
pOutFileStream?.Link(instream);
return pOutFileStream;
}
public IOutFileStream CreateOutFileStream(BaseProtocol protocol,string name,string filePath,bool append)
{
var meta = GetMetaData(name, false,protocol.Application.Configuration);
string fileName = meta[Defines.META_SERVER_MEDIA_DIR];
fileName += meta[Defines.META_SERVER_FILE_NAME];
this.Log().Info("fileName: {0}", fileName);
IOutFileStream pOutFileStream = null;
switch ((string)meta[Defines.META_MEDIA_TYPE])
{
case Defines.MEDIA_TYPE_FLV:
case Defines.MEDIA_TYPE_LIVE_OR_FLV:
if (append)
{
//删除原来的辅助文件
var seekPath = meta[Defines.META_SERVER_FULL_PATH] + "." + Defines.MEDIA_TYPE_SEEK;
var metaDataPath = meta[Defines.META_SERVER_FULL_PATH] + "." + Defines.MEDIA_TYPE_META;
File.Delete(seekPath);
File.Delete(metaDataPath);
}
pOutFileStream = new OutFileRTMPFLVStream(protocol, Application.StreamsManager, filePath??fileName, name) { Appending = append };
break;
case Defines.MEDIA_TYPE_MP4:
Logger.FATAL("Streaming to MP4 file not supported");
break;
default:
Logger.FATAL("Media type not supported");
break;
}
return pOutFileStream;
}
public abstract void SharedObjectTrack(BaseProtocol to, string name, uint version, bool isPersistent, Variant primitives);
public static UDPCarrier Create(string bindIp, ushort bindPort,BaseProtocol pProtocol)
{
if (pProtocol == null)
{
Logger.FATAL("Protocol can't be null");
return null;
}
UDPCarrier pResult = Create(bindIp, bindPort);
if (pResult == null)
{
Logger.FATAL("Unable to create UDP carrier");
return null;
}
pResult.Protocol = pProtocol.FarEndpoint;
pProtocol.FarEndpoint.IOHandler = pResult;
return pResult;
}
public virtual void Dispose()
{
if (_farProtocol != null)
{
_farProtocol._nearProtocol = null;
if (DeleteFarProtocol)
_farProtocol.EnqueueForDelete();
_farProtocol = null;
}
if (_nearProtocol != null)
{
_nearProtocol._farProtocol = null;
if (DeleteNearProtocol)
_nearProtocol.EnqueueForDelete();
_nearProtocol = null;
}
this.UnRegisterProtocol();
}
public override BaseProtocol SpawnProtocol(ulong type, Variant parameters)
{
BaseProtocol pResult = null;
switch (type)
{
case ProtocolTypes.PT_TCP:
pResult = new TCPProtocol();
break;
case ProtocolTypes.PT_UDP:
pResult = new UDPProtocol();
break;
case ProtocolTypes.PT_INBOUND_SSL:
pResult = new InboundSSLProtocol();
break;
case ProtocolTypes.PT_OUTBOUND_SSL:
pResult = new OutboundSSLProtocol();
break;
case ProtocolTypes.PT_INBOUND_RTMP:
pResult = new InboundRTMPProtocol();
break;
case ProtocolTypes.PT_INBOUND_RTMPS_DISC:
break;
case ProtocolTypes.PT_OUTBOUND_RTMP:
pResult = new OutboundRTMPProtocol();
break;
case ProtocolTypes.PT_INBOUND_RTMFP:
pResult = new InboundRTMFPProtocol();
break;
case ProtocolTypes.PT_INBOUND_CLUSTER:
pResult = new InboundClusterProtocol();
break;
case ProtocolTypes.PT_OUTBOUND_CLUSTER:
pResult = new OutboundClusterProtocol();
break;
case ProtocolTypes.PT_RTSP:
pResult = new RtspProtocol();
break;
case ProtocolTypes.PT_RTP_NAT_TRAVERSAL:
pResult = new NATTraversalProtocol();
break;
case ProtocolTypes.PT_INBOUND_RTP:
pResult = new InboundRtpProtocol();
break;
case ProtocolTypes.PT_RTCP:
pResult = new RtcpProtocol();
break;
case ProtocolTypes.PT_INBOUND_WEBSOCKET:
pResult = new WebSocketProtocol();
break;
case ProtocolTypes.PT_INBOUND_WEBRTC_SIGNAL:
pResult = new WebRtcSignalProtocol();
break;
case ProtocolTypes.PT_INBOUND_MP4:
pResult = new Mp4Protocol();
break;
default:
Logger.FATAL("Spawning protocol {0} not yet implemented",
type.TagToString());
break;
}
if (pResult != null)
{
if (!pResult.Initialize(parameters))
{
Logger.FATAL("Unable to initialize protocol {0}",
type.TagToString());
pResult = null;
}
}
return(pResult);
}
public abstract void UnRegisterProtocol(BaseProtocol protocol);
public Variant Test(BaseProtocol pFrom, Variant invoke)
{
var result = new Variant();
result["catagory"] = new Variant(PerformanceCounterCategory.GetCategories().Select(x=>new Variant(x.CategoryName)).ToList());
return result;
}
public static BaseClientApplication SwitchRoom(BaseProtocol from,string roomFullName, Variant configuration)
{
var appName = GetAppName(roomFullName);
if (((string) configuration[Defines.CONF_APPLICATION_NAME]).Split('/')[0] != appName)
{
return from.Application = GetOrCreateRoom(roomFullName);
}
if (roomFullName == (string) configuration[Defines.CONF_APPLICATION_NAME] || string.IsNullOrEmpty(roomFullName))
{//为自身
return from.Application;
}
var app = FindAppByName(roomFullName) ?? CreateRoom(from.Application, roomFullName);
from.Application = app;
return app;
}
public abstract void CallClient(BaseProtocol to, string functionName, Variant param);
public void ResetFarProtocol()
{
if (_farProtocol != null)
_farProtocol._nearProtocol = null;
_farProtocol = null;
}
