public UploadCommand(IMessageObserver observer, IGoulRequestHandler gRequestHandler, ICredentialStore credentialStore, IRefreshTokenStore refreshStore)
{
mObserver = observer;
mHandler = gRequestHandler;
mCredentialStore = credentialStore;
mRefreshStore = refreshStore;
}
public AuthorizeCommand(IMessageObserver observer, IRefreshTokenStore refreshStorage, ICredentialStore credentialStore, IGoulRequestHandler handler)
{
mObserver = observer;
mRefreshStorage = refreshStorage;
mCredStore = credentialStore;
mHandler = handler;
}
public Client(TcpClient client, string ipAddress, int port, IMessageObserver observer)
{
tcpClient = client;
client.Connect(ipAddress, port);
stream = client.GetStream();
State = ClientState.Active;
new Thread(new ThreadStart(tReceive)).Start();
}
public GetAuthorizationUrlCommand(IMessageObserver observer,
ICredentialStore credentialStore,
IGoulRequestHandler handler)
{
mObserver = observer;
mCredentialStore = credentialStore;
mHandler = handler;
}
public Listener(int port, IMessageObserver observer, IConnectObserver connectObserver)
{
currentId = 0;
this.observer = observer;
this.connectObserver = connectObserver;
connectedClients = new List<Client>();
tcpListener = new TcpListener(IPAddress.Any, port);
new Thread(new ThreadStart(tClientListener)).Start();
}
public Client(TcpClient client, IMessageObserver observer, int id)
{
this.Id = id;
this.observer = observer;
tcpClient = client;
stream = client.GetStream();
State = ClientState.Active;
new Thread(new ThreadStart(tReceive)).Start();
}
public void AddMessageObserver(IMessageObserver pObserver)
{
if (pObserver == null)
{
throw new ArgumentNullException("pObserver");
}
pObserver.DisposeUnsubscriber =
base.Subscribe(new InternalMessageObserver(pObserver));
}
public async Task Unsubscribe(IMessageObserver observer)
{
this.observers.Unsubscribe(observer);
if (this.observers.Count == 0)
{
var manager = PubSubManagerFactory.GetGrain(0);
await manager.Unregister(this);
this.DeactivateOnIdle(); // remove this grain
}
}
public async Task Unsubscribe(IMessageObserver observer)
{
this.observers.Unsubscribe(observer);
if (this.observers.Count == 0)
{
var manager = PubSubManagerFactory.GetGrain(0);
await manager.Unregister(this);
this.DeactivateOnIdle(); // remove this grain
}
}
/// <summary>
/// Create an instance of this class and subscribes to messages that are broadcasted to the "all" stream for the hub
/// </summary>
/// <param name="groupActorProvider"></param>
/// <param name="userActorProvider"></param>
/// <param name="messageObservable"></param>
/// <param name="messageObserver"></param>
/// <param name="cancellationToken"></param>
/// <returns>A new instance of <see cref="OrgnalRHubLifetimeManager<THub>" /> that is subscribed to the anonymous message broadcasts</returns>
public static async Task <OrgnalRHubLifetimeManager <THub> > CreateAsync(
IGroupActorProvider groupActorProvider,
IUserActorProvider userActorProvider,
IMessageObservable messageObservable,
IMessageObserver messageObserver,
ILogger <OrgnalRHubLifetimeManager <THub> > logger,
CancellationToken cancellationToken = default
)
{
var manager = new OrgnalRHubLifetimeManager <THub>(groupActorProvider, userActorProvider, messageObservable, messageObserver, logger);
manager.allSubscriptionHandle = await messageObservable.SubscribeToAllAsync(manager.OnAnonymousMessageReceived, manager.OnAnonymousSubscriptionEnd, default, cancellationToken).ConfigureAwait(false);
private OrgnalRHubLifetimeManager(
IGroupActorProvider groupActorProvider,
IUserActorProvider userActorProvider,
IMessageObservable messageObservable,
IMessageObserver messageObserver,
ILogger <OrgnalRHubLifetimeManager <THub> > logger
)
{
this.groupActorProvider = groupActorProvider ?? throw new ArgumentNullException(nameof(groupActorProvider));
this.userActorProvider = userActorProvider ?? throw new ArgumentNullException(nameof(userActorProvider));
this.messageObservable = messageObservable ?? throw new ArgumentNullException(nameof(messageObservable));
this.messageObserver = messageObserver ?? throw new ArgumentNullException(nameof(messageObserver));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public OrleansMessageBus(IDependencyResolver resolver, ScaleoutConfiguration configuration)
: base(resolver, configuration)
{
grain = PubSubGrainFactory.GetGrain(Guid.NewGuid());
subscriber = new MessageObserver((messages) =>
{
lock (grain)
{
OnReceived(messages[0].StreamIndex, messages.Select(x => x.MappingId).Max(), new ScaleoutMessage(messages));
}
});
subscriberReference = MessageObserverFactory.CreateObjectReference(subscriber).Result;
grain.Subscribe(subscriberReference).Wait();
}
public OrleansMessageBus(IDependencyResolver resolver, ScaleoutConfiguration configuration)
: base(resolver, configuration)
{
grain = PubSubGrainFactory.GetGrain(Guid.NewGuid());
subscriber = new MessageObserver((messages) =>
{
lock (grain)
{
OnReceived(messages[0].StreamIndex, messages.Select(x => x.MappingId).Max(), new ScaleoutMessage(messages));
}
});
subscriberReference = MessageObserverFactory.CreateObjectReference(subscriber).Result;
grain.Subscribe(subscriberReference).Wait();
}
public Task Subscribe(IMessageObserver observer)
{
this.observers.Subscribe(observer);
return(TaskDone.Done);
}
public Task Subscribe(IMessageObserver observer)
{
this.observers.Subscribe(observer);
return TaskDone.Done;
}
public void RegisterMessageObserver(IMessageObserver handler)
{
_observers.Add(handler);
}
/// <summary>
/// Subscribes the specified event observer which should be notfied in case of an message.
/// </summary>
/// <param name="messageObserver">The message observer.</param>
void IEventBus.Subscribe(IMessageObserver messageObserver)
{
_observers.Add(messageObserver);
}
public virtual void RegisterObserver(IMessageObserver observer)
{
_observers.Add(observer);
}
public virtual void RegisterObserver(IMessageObserver observer)
{
_observers.Add(observer);
}
public void registerMessageObserver(IMessageObserver observer)
{
messageObservers.Add(observer);
}
public Task UnsubscribeAsync(IMessageObserver messageGrain)
{
_subsManager.Unsubscribe(messageGrain);
return(Task.CompletedTask);
}
public MessageObserversController RemoveObserver(IMessageObserver messageObserver)
{
_messageObservers.Remove(messageObserver);
return(this);
}
public MessageObserversController AddObservers(IMessageObserver messageObserver)
{
_messageObservers.Add(messageObserver);
return(this);
}
public Message(MessageType _type, string _data = "", IMessageObserver _entity = null)
{
data = _data;
type = _type;
entity = _entity;
}
public void AddObserver(IMessageObserver newObserver)
{
observerList.Add(newObserver);
}
public static void Unsubscribe(IMessageObserver obs)
{
observerList.Remove(obs);
}
/// <summary>
/// Subscribes the specified message observer which should be notified in case of any message.
/// </summary>
/// <param name="messageObserver">The message observer.</param>
public void Subscribe(IMessageObserver messageObserver)
{
_observers.Add(messageObserver);
}
public InternalMessageObserver(IMessageObserver pMessageObserver)
{
messageObserver = pMessageObserver;
}
public static void Run(string discoveryFolder, string templateFolder, string teamCityUrl, string teamCityUsername, string teamCityPassword, bool overwrite, IMessageObserver observer)
{
var buildProjects = Directory.GetFiles(discoveryFolder, "*.sln", SearchOption.AllDirectories)
.Select(x => new BuildProject(x));
foreach (var buildProject in buildProjects)
{
TeamCityProject tcp = null;
var projectTree = buildProject.Name.Split('.').ToList();
projectTree.Add(buildProject.Branch.Replace(".", string.Empty));
for (var i = 0; i < projectTree.Count; i++)
{
var projectId = string.Join("_", projectTree.GetRange(0, i + 1));
tcp = GetProject(projectId, teamCityUrl, teamCityUsername, teamCityPassword);
if ((i == (projectTree.Count - 1)) && overwrite && tcp != null && tcp.BuildConfigurations != null && tcp.BuildConfigurations.Any())
{
DeleteProject(tcp.Id, teamCityUrl, teamCityUsername, teamCityPassword);
tcp = null;
}
if (tcp == null)
{
observer.Notify("CreateProject: {0}", projectId);
tcp = CreateProject(projectTree[i], projectId, string.Join("_", projectTree.GetRange(0, i)),
teamCityUrl, teamCityUsername, teamCityPassword);
}
else
{
observer.Notify("{0} exists", projectId);
}
}
if (tcp != null)
{
foreach (var buildConfig in new[] { "Build", "Drop", "Release" })
{
var buildId = string.Concat(tcp.Id, "_", buildConfig);
if (overwrite || tcp.BuildConfigurations == null || !tcp.BuildConfigurations.Any(x => x.Id.Equals(buildId)))
{
observer.Notify("/{0}", buildId.Replace('_', '/'));
var bc = CreateBuildConfiguration(buildConfig, buildId, tcp.Id, teamCityUrl, teamCityUsername, teamCityPassword);
var xml = XDocument.Load(Path.Combine(templateFolder, string.Concat(buildConfig, ".xml"))).Root;
observer.Notify(" - Settings");
foreach (var setting in xml.Descendants("option").Select(x => new { Name = x.Attribute("name").Value, x.Attribute("value").Value }))
{
var url = string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/settings/", setting.Name);
var payload = (setting.Name == "buildNumberPattern" && buildConfig != "Build")
? string.Format(setting.Value, buildConfig == "Drop" ? buildId.Replace("_Drop", "_Build") : buildId.Replace("_Release", "_Drop"))
: setting.Value;
observer.Notify(" - Setting: {0}, value: {1}", setting.Name, payload);
Put(url, payload, teamCityUsername, teamCityPassword);
}
observer.Notify(" - Parameters");
foreach (var param in xml.Descendants("param").Select(x => new { Name = x.Attribute("name").Value, x.Attribute("value").Value }))
{
var url = string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/parameters/", param.Name);
var payload = param.Value;
observer.Notify(" - Parameter: {0}, value: {1}", param.Name, payload);
Put(url, payload, teamCityUsername, teamCityPassword);
}
observer.Notify(" - Steps");
foreach (var stepXml in xml.Descendants("step"))
{
//build step special case: package web application for web deploy. repeat step for each web project in solution.
switch (stepXml.Attribute("id").Value)
{
case "RUNNER_128":
foreach (var sp in buildProject.Solution.Projects.Where(x => x.OutputClass == OutputClass.WebDeploy))
{
observer.Notify(" - Step: {0}", stepXml.Attribute("name").Value.Replace("{0}", sp.ProjectName));
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/steps"),
stepXml.ToString()
.Replace("{0}", sp.ProjectName)
.Replace("{1}", Path.Combine("Source", sp.RelativePath)),
teamCityUsername, teamCityPassword);
}
break;
default:
observer.Notify(" - Step: {0}", stepXml.Attribute("name").Value);
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/steps"),
stepXml.ToString().Replace("{0}", string.Concat(@"Source\", buildProject.Name, ".sln")),
teamCityUsername, teamCityPassword);
break;
}
}
observer.Notify(" - Features");
foreach (var featureXml in xml.Descendants("feature").Select(x => x.ToString()))
{
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/features"),
featureXml,
teamCityUsername, teamCityPassword);
}
observer.Notify(" - Triggers");
foreach (var triggerXml in xml.Descendants("trigger").Select(x => x.ToString()))
{
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/triggers"),
triggerXml,
teamCityUsername, teamCityPassword);
}
switch (buildConfig)
{
case "Build":
if (/*buildProject.Artifacts.Any()*/ true)
{
observer.Notify(" - Artifacts");
Put(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/settings/artifactRules"),
string.Join("\n", buildProject.Solution.Projects.Where(x => x.Artifact != null).Select(x => string.Format("{0} => {1}.zip", x.Artifact.RelativePath, x.Artifact.Name))),
teamCityUsername, teamCityPassword);
}
if (!string.IsNullOrWhiteSpace(buildProject.VcsRoot) && buildProject.VcsRoot.StartsWith("//depot/", StringComparison.InvariantCultureIgnoreCase))
{
observer.Notify(" - VcsRoots");
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/vcs-roots"),
string.Format(File.ReadAllText(Path.Combine(templateFolder, "vcs-p4.xml")),
string.Concat(tcp.Id, "_Source"),
"Source",
tcp.Id,
tcp.Name,
buildProject.VcsRoot,
"svc_tcbuild_dev",
"Gti%xEkf&8yj"),
teamCityUsername, teamCityPassword);
foreach (var vcsRootXml in xml.Descendants("vcs-root-entry").Select(x => x.ToString()))
{
observer.Notify(" - VcsRoot: {0}", string.Concat(tcp.Id, "_Source"));
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/vcs-root-entries"),
string.Format(vcsRootXml,
string.Concat(tcp.Id, "_Source"),
"Source"),
teamCityUsername, teamCityPassword);
}
}
break;
case "Drop":
observer.Notify(" - ArtifactDependencies");
foreach (var dependencyXml in xml.Descendants("artifact-dependency").Select(x => x.ToString()))
{
observer.Notify(" - ArtifactDependency: {0}", buildId.Replace("_Drop", "_Build"));
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/artifact-dependencies"),
string.Format(dependencyXml,
buildId.Replace("_Drop", "_Build"),
"Build",
tcp.Id,
tcp.Name,
//test this dependency artifact rule when you get back from the pub!
string.Join("
", buildProject.Solution.Projects.Where(x => x.Artifact != null).Select(x => string.Format("+:{0}.zip!** => {0}", x.Artifact.Name)))),
teamCityUsername, teamCityPassword);
}
observer.Notify(" - SnapshotDependencies");
foreach (var dependencyXml in xml.Descendants("snapshot-dependency").Select(x => x.ToString()))
{
observer.Notify(" - SnapshotDependency: {0}", buildId.Replace("_Drop", "_Build"));
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/snapshot-dependencies"),
string.Format(dependencyXml,
buildId.Replace("_Drop", "_Build"),
"Build",
tcp.Id,
tcp.Name),
teamCityUsername, teamCityPassword);
}
observer.Notify(" - VcsRoots");
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/vcs-roots"),
string.Format(File.ReadAllText(Path.Combine(templateFolder, "vcs-robocopy.xml")),
string.Concat(tcp.Id, "_RoboCopy"),
"RoboCopy",
tcp.Id,
tcp.Name),
teamCityUsername, teamCityPassword);
foreach (var vcsRootXml in xml.Descendants("vcs-root-entry").Select(x => x.ToString()))
{
observer.Notify(" - VcsRoot: {0}", string.Concat(tcp.Id, "_RoboCopy"));
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/vcs-root-entries"),
string.Format(vcsRootXml,
string.Concat(tcp.Id, "_RoboCopy"),
"RoboCopy"),
teamCityUsername, teamCityPassword);
}
observer.Notify(" - Artifacts");
Put(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/settings/artifactRules"),
@"%drop_folder%\%build.number% => artifacts.zip",
teamCityUsername, teamCityPassword);
break;
case "Release":
observer.Notify(" - ArtifactDependencies");
foreach (var dependencyXml in xml.Descendants("artifact-dependency").Select(x => x.ToString()))
{
observer.Notify(" -ArtifactDependency: {0}", buildId.Replace("_Release", "_Drop"));
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/artifact-dependencies"),
string.Format(dependencyXml,
buildId.Replace("_Release", "_Drop"),
"Drop",
tcp.Id,
tcp.Name),
teamCityUsername, teamCityPassword);
}
observer.Notify(" - SnapshotDependencies");
foreach (var dependencyXml in xml.Descendants("snapshot-dependency").Select(x => x.ToString()))
{
observer.Notify(" - SnapshotDependency: {0}", buildId.Replace("_Release", "_Drop"));
Post(
string.Concat(teamCityUrl, "/httpAuth/app/rest/buildTypes/", bc.Id, "/snapshot-dependencies"),
string.Format(dependencyXml,
buildId.Replace("_Release", "_Drop"),
"Drop",
tcp.Id,
tcp.Name),
teamCityUsername, teamCityPassword);
}
break;
}
}
}
}
}
}
public void RemoveObserver(IMessageObserver newObserver)
{
observerList.Remove(newObserver);
}
public void Add(IMessageObserver observer)
{
observers.Add(observer);
}
public void AddObserver(IMessageObserver newObserver)
{
observerList.Add(newObserver);
}
public SetCredentialsCommand(IMessageObserver observer, ICredentialStore storage)
{
mObserver = observer;
mStorage = storage;
}
public static void Subscribe(IMessageObserver obs)
{
observerList.Add(obs);
}
public ListCredentialsCommand(IMessageObserver observer, IFile file)
{
mObserver = observer;
mFile = file;
}
public HelpCommand(IMessageObserver observer)
{
mObserver = observer;
}
public static void SendMessage(Message message, IMessageObserver to)
{
to.OnMessage(message);
}
public void RemoveObserver(IMessageObserver newObserver)
{
observerList.Remove(newObserver);
}
