/// <summary>
/// Starts an asynchronous operation to push urls to baidu.com.
/// </summary>
/// <param name="site"></param>
/// <param name="token"></param>
/// <param name="urls"></param>
/// <param name="callback"></param>
/// <param name="userState"></param>
/// <returns></returns>
public static IAsyncResult BeginPush(string site, string token, bool isOriginal, IEnumerable <string> urls, AsyncCallback callback, object userState)
{
HttpWebRequest request = CreatePushRequest(site, token, isOriginal);
AsyncResult <IBaiduPushResult> result = new AsyncResult <IBaiduPushResult>(callback, userState);
byte[] data = Encoding.UTF8.GetBytes(urls.StringJoin("\r\n"));
request.ContentLength = data.Length;
NetworkRequestAsyncTimeout.RegisterRequest(request.BeginGetRequestStream((streamResult) => {
try {
using (Stream writer = ((HttpWebRequest)streamResult.AsyncState).EndGetRequestStream(streamResult)) {
writer.Write(data, 0, data.Length);
}
} catch (Exception ex) {
result.MarkCompleted(ex, false, null);
return;
}
NetworkRequestAsyncTimeout.RegisterRequest(((HttpWebRequest)streamResult.AsyncState).BeginGetResponse((contentResult) => {
string content = null;
Exception error = null;
PushResult pushResult = null;
byte[] buffer = g_bufferManager.TakeBuffer(BUFFER_SIZE);
try {
using (HttpWebResponse response = (HttpWebResponse)((HttpWebRequest)contentResult.AsyncState).EndGetResponse(contentResult)) {
if (!string.IsNullOrWhiteSpace(content = response.GetResponseString(buffer)))
{
pushResult = new JavaScriptSerializer().Deserialize <PushResult>(content);
}
}
} catch (WebException ex) {
try {
using (HttpWebResponse response = (HttpWebResponse)ex.Response) {
if (response != null)
{
if (!string.IsNullOrWhiteSpace(content = response.GetResponseString(buffer)))
{
pushResult = new JavaScriptSerializer().Deserialize <PushResult>(content);
}
}
else
{
error = ex;
}
}
} catch {
error = ex;
}
} catch (Exception ex) {
error = ex;
} finally {
g_bufferManager.ReturnBuffer(buffer);
}
result.MarkCompleted(error, false, pushResult);
}, request), request, TIMEOUT);
}, request), request, TIMEOUT);
return(result);
}
/// <summary>
/// 接收推送消息
/// </summary>
/// <param name="xml">请求消息</param>
/// <param name="configData">configData</param>
/// <returns>处理结果</returns>
public static PushResult ReceivePushMessage(string xml, ConfigData configData)
{
PushRequest pushRequest = new PushRequest
{
Xml = xml,
EncodingAESKey = configData.EncodingAESKey,
ComponentVerifyTicket = configData.component_verify_ticket_key,
ValidityTime = DateTime.Now.AddDays(1)
};
XElement doc = XElement.Parse(pushRequest.Xml);
var encry = doc.Element("Encrypt").GetString();
string encodingAESKey = pushRequest.EncodingAESKey;
string appid = string.Empty;
var xmlContent = Cryptography.AES_decrypt(encry, encodingAESKey, ref appid);
PushResult pushResult = TenpayUtil.ConvertToPushRequest(xmlContent);
if (pushResult.InfoType == "component_verify_ticket")
{
// 写入缓存
//Redis.SetRedis(pushRequest.ComponentVerifyTicket, pushResult.ComponentVerifyTicket, pushRequest.ValidityTime);
pushResult.IsSucceed = !string.IsNullOrEmpty(pushRequest.ComponentVerifyTicket);
}
else
{
pushResult.IsSucceed = false;
pushResult.Message = $"暂不处理类型{pushResult.InfoType}";
}
return(pushResult);
}
/// <summary>
/// Sends the message to binding receivers
/// </summary>
public override async Task <bool> Send(MqClient sender, HorseMessage message)
{
try
{
HorseQueue queue = await GetQueue(message);
if (queue == null)
{
return(false);
}
string messageId = Interaction == BindingInteraction.None
? Router.Server.MessageIdGenerator.Create()
: message.MessageId;
HorseMessage msg = message.Clone(true, true, messageId);
msg.Type = MessageType.QueueMessage;
msg.SetTarget(Target);
msg.WaitResponse = Interaction == BindingInteraction.Response;
QueueMessage queueMessage = new QueueMessage(msg);
queueMessage.Source = sender;
PushResult result = await queue.Push(queueMessage, sender);
return(result == PushResult.Success);
}
catch (Exception e)
{
Router.Server.SendError("BINDING_SEND", e, $"Type:AutoQueue, Binding:{Name}");
return(false);
}
}
/// <summary>
/// Handles pushing a message into a queue
/// </summary>
private async Task HandlePush(MqClient client, TmqMessage message, ChannelQueue queue)
{
//check authority
if (_server.Authorization != null)
{
bool grant = await _server.Authorization.CanMessageToQueue(client, queue, message);
if (!grant)
{
if (!string.IsNullOrEmpty(message.MessageId))
{
await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized));
}
return;
}
}
//prepare the message
QueueMessage queueMessage = new QueueMessage(message);
queueMessage.Source = client;
//push the message
PushResult result = await queue.Push(queueMessage, client);
if (result == PushResult.StatusNotSupported)
{
await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unacceptable));
}
else if (result == PushResult.LimitExceeded)
{
await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.LimitExceeded));
}
}
/// <summary>
/// Start to process all pending messages.
/// This method is called after a client is subscribed to the queue.
/// </summary>
private async Task ProcessPendingMessages(bool high)
{
while (true)
{
QueueMessage message;
if (high)
{
lock (_queue.HighPriorityLinkedList)
{
if (_queue.HighPriorityLinkedList.Count == 0)
{
return;
}
message = _queue.HighPriorityLinkedList.First.Value;
_queue.HighPriorityLinkedList.RemoveFirst();
message.IsInQueue = false;
}
}
else
{
lock (_queue.RegularLinkedList)
{
if (_queue.RegularLinkedList.Count == 0)
{
return;
}
message = _queue.RegularLinkedList.First.Value;
_queue.RegularLinkedList.RemoveFirst();
message.IsInQueue = false;
}
}
try
{
PushResult pr = await ProcessMessage(message);
if (pr == PushResult.Empty || pr == PushResult.NoConsumers)
{
return;
}
}
catch (Exception ex)
{
_queue.Info.AddError();
try
{
Decision decision = await _queue.DeliveryHandler.ExceptionThrown(_queue, message, ex);
await _queue.ApplyDecision(decision, message);
}
catch //if developer does wrong operation, we should not stop
{
}
}
}
}
public async Task <PushResult> Push(QueueMessage message)
{
ProcessingMessage = message;
PushResult result = await ProcessMessage(message);
ProcessingMessage = null;
return(result);
}
/// <summary>
/// Start to process all pending messages.
/// This method is called after a client is subscribed to the queue.
/// </summary>
private async Task ProcessPendingMessages(bool high)
{
while (State.TriggerSupported)
{
QueueMessage message;
if (high)
{
lock (HighPriorityLinkedList)
{
if (HighPriorityLinkedList.Count == 0)
{
return;
}
message = HighPriorityLinkedList.First.Value;
HighPriorityLinkedList.RemoveFirst();
message.IsInQueue = false;
}
}
else
{
lock (RegularLinkedList)
{
if (RegularLinkedList.Count == 0)
{
return;
}
message = RegularLinkedList.First.Value;
RegularLinkedList.RemoveFirst();
message.IsInQueue = false;
}
}
try
{
PushResult pr = await State.Push(message);
if (pr == PushResult.Empty || pr == PushResult.NoConsumers)
{
return;
}
}
catch (Exception ex)
{
Info.AddError();
try
{
Decision decision = await DeliveryHandler.ExceptionThrown(this, message, ex);
await ApplyDecision(decision, message);
}
catch //if developer does wrong operation, we should not stop
{
}
}
}
}
public void testTrackingRefUpdateOnReject()
{
RemoteRefUpdate rru = new RemoteRefUpdate(db, "ac7e7e44c1885efb472ad54a78327d66bfc4ecef", "refs/heads/master", false, null, null);
Core.Ref @ref = new Core.Ref(Core.Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9"));
PushResult result = testOneUpdateStatus(rru, @ref, RemoteRefUpdate.UpdateStatus.REJECTED_NONFASTFORWARD, null);
Assert.IsTrue(result.TrackingRefUpdates.Count == 0);
}
public void ShouldReturnValueForAValidRef()
{
var result = new PushResult();
var r = new Core.Ref(null, "ref", ObjectId.ZeroId);
result.AdvertisedRefs.Add("ref", r);
Assert.AreEqual(r, result.GetAdvertisedRef("ref"));
}
public static async Task Main(string[] args)
{
RongCloud rongCloud = RongCloud.GetInstance(appKey, appSecret);
/**
*
* API 文档:
* https://www.rongcloud.cn/docs/push_service.html#broadcast
*
* 广播消息
*
**/
BroadcastModel broadcast = new BroadcastModel();
broadcast.SetFromuserid("fromuserid");
broadcast.SetPlatform(new string[] { "ios", "android" });
Audience audience = new Audience();
audience.SetUserid(new string[] { "userid1", "userid2" });
broadcast.SetAudience(audience);
Message message = new Message();
message.SetContent("this is message");
message.SetObjectName("RC:TxtMsg");
broadcast.SetMessage(message);
Notification notification = new Notification();
notification.SetAlert("this is broadcast");
broadcast.SetNotification(notification);
PushResult result = await rongCloud.Broadcast.Send(broadcast);
Console.WriteLine("broadcast: " + result);
/**
*
* API 文档:
* https://www.rongcloud.cn/docs/push_service.html#push
*
* 推送消息
*
**/
PushModel pushmodel = new PushModel();
pushmodel.SetPlatform(new string[] { "ios", "android" });
audience = new Audience();
audience.SetUserid(new string[] { "userid1", "userid2" });
pushmodel.SetAudience(audience);
notification = new Notification();
notification.SetAlert("this is push");
pushmodel.SetNotification(notification);
result = await rongCloud.Push.Send(pushmodel);
Console.WriteLine("push: " + result);
Console.ReadLine();
}
public async static void DequeueTask(object state)
{
CancellationToken token = (CancellationToken)state;
while (!token.IsCancellationRequested)
{
if (dequeueSignal.WaitOne()) // block untill we have items in the queue
{
NotificationDelivery delivery = null;
if (deliveryQueue.TryDequeue(out delivery))
{
NotificationDeliveryStatus ns = NotificationDeliveryStatus.Pending;
if (delivery.Subscription.Status == SubscriptionStatus.Subscribed)
{
PushResult result = await PushService.DoPushAsync(delivery);
switch (result)
{
case PushResult.Pushed:
ns = NotificationDeliveryStatus.Delivered;
break;
case PushResult.Error:
ns = NotificationDeliveryStatus.FailureError;
break;
case PushResult.NotSupported:
ns = NotificationDeliveryStatus.FailureNotSupported;
break;
case PushResult.UnSubscribed:
ns = NotificationDeliveryStatus.FailureUnSubscribed;
delivery.Subscription.Status = SubscriptionStatus.UnSubscribed;
break;
}
}
else
{
ns = NotificationDeliveryStatus.FailureUnSubscribed;
}
delivery.Status = ns;
delivery.DeliveredAt = DateTime.Now;
}
else
{
// empty queue, no more items
// stop dequeueing untill new items added by EnqueueTask
dequeueSignal.Reset();
}
}
}
}
public async Task <PushResult> Push(QueueMessage message, MqClient sender)
{
ProcessingMessage = message;
PushResult result = await ProcessMessage(message, sender);
ProcessingMessage = null;
await _queue.Trigger();
return(result);
}
/// <summary>
/// Model转化
/// </summary>
/// <param name="xml">xml</param>
/// <returns>推送结果</returns>
public static PushResult ConvertToPushRequest(string xml)
{
PushResult pushResult = new PushResult();
XElement doc = XElement.Parse(xml);
pushResult.AppId = doc.Element("AppId").GetString();
pushResult.CreateTime = doc.Element("CreateTime").GetString();
pushResult.InfoType = doc.Element("InfoType").GetString();
pushResult.ComponentVerifyTicket = doc.Element("ComponentVerifyTicket").GetString();
return(pushResult);
}
public void testTrackingRefUpdateDisabled()
{
RemoteRefUpdate rru = new RemoteRefUpdate(db, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", "refs/heads/master", false, null, null);
Core.Ref @ref = new Core.Ref(Core.Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
refUpdates.Add(rru);
advertisedRefs.Add(@ref);
PushResult result = executePush();
Assert.IsTrue(result.TrackingRefUpdates.Count == 0);
}
public void ShouldReturnValueForAValidRef()
{
var result = new PushResult();
var r = new Unpeeled(null, "ref", ObjectId.ZeroId);
var refs = result.AdvertisedRefs;
var advRefs = refs.ToDictionary(@ref => @ref.Name);
advRefs.Add("ref", r);
result.SetAdvertisedRefs(result.URI, advRefs);
Assert.AreEqual(r, result.GetAdvertisedRef("ref"));
}
public void testTrackingRefUpdateEnabled()
{
RemoteRefUpdate rru = new RemoteRefUpdate(db, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", "refs/heads/master", false, "refs/remotes/test/master", null);
Core.Ref @ref = new Core.Ref(Core.Ref.Storage.Loose, "refs/heads/master", ObjectId.FromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
refUpdates.Add(rru);
advertisedRefs.Add(@ref);
PushResult result = executePush();
TrackingRefUpdate tru = result.GetTrackingRefUpdate("refs/remotes/test/master");
Assert.IsNotNull(tru);
Assert.AreEqual("refs/remotes/test/master", tru.LocalName);
Assert.AreEqual(RefUpdate.RefUpdateResult.New, tru.Result);
}
static void Main(string[] args)
{
JPushServer server = new JPushServer("YOUR_APP_KEY", "YOUR_MASTER_SECRET");
Dictionary <string, object> dict = new Dictionary <string, object>();
dict.Add("key", "value");
AudienceObject.RegistrationIDs regIDs = new AudienceObject.RegistrationIDs
{
registration_id = new string[] { "REGISTRATIONID" }
};
PushResult pushResult = server.Push("message", "title", JPushLibrary.Enum.Platform.iOSProductionAndAndroid, regIDs, dict, JPushLibrary.Enum.AndroidPriority.PRIORITY_HIGH, JPushLibrary.Enum.AndroidAlertType.All);
PushResult slientPushResult = server.PushSlient(dict, JPushLibrary.Enum.Platform.iOSProductionAndAndroid, null, JPushLibrary.Enum.AndroidPriority.PRIORITY_HIGH, "message", "title");
}
public async Task <PushResult> Push(QueueMessage message)
{
try
{
ProcessingMessage = message;
PushResult result = await ProcessMessage(message);
ProcessingMessage = null;
return(result);
}
catch (Exception e)
{
_queue.Server.SendError("PUSH", e, $"QueueName:{_queue.Name}, State:Push");
return(PushResult.Error);
}
}
private PushResult testOneUpdateStatus(RemoteRefUpdate rru, Core.Ref advertisedRef, RemoteRefUpdate.UpdateStatus expectedStatus, bool?fastForward)
{
refUpdates.Add(rru);
if (advertisedRef != null)
{
advertisedRefs.Add(advertisedRef);
}
PushResult result = executePush();
Assert.AreEqual(expectedStatus, rru.Status);
if (fastForward.HasValue)
{
Assert.AreEqual(fastForward.Value, rru.FastForward);
}
return(result);
}
public void testPushResult()
{
RemoteRefUpdate rru = new RemoteRefUpdate(db, "2c349335b7f797072cf729c4f3bb0914ecb6dec9",
"refs/heads/master", false, "refs/remotes/test/master", null);
Core.Ref @ref = new Unpeeled(Storage.Loose, "refs/heads/master", ObjectId.FromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
refUpdates.Add(rru);
advertisedRefs.Add(@ref);
PushResult result = executePush();
Assert.AreEqual(1, result.TrackingRefUpdates.Count);
Assert.AreEqual(1, result.AdvertisedRefs.Count);
Assert.AreEqual(1, result.RemoteUpdates.Count);
Assert.IsNotNull(result.GetTrackingRefUpdate("refs/remotes/test/master"));
Assert.IsNotNull(result.GetAdvertisedRef("refs/heads/master"));
Assert.IsNotNull(result.GetRemoteUpdate("refs/heads/master"));
}
public async Task <PushResult> Push(QueueMessage message)
{
ChannelClient cc = _queue.Channel.GetNextRRClient(ref _roundRobinIndex);
if (cc == null)
{
_queue.AddMessage(message, false);
return(PushResult.NoConsumers);
}
ProcessingMessage = message;
PushResult result = await ProcessMessage(message, cc);
ProcessingMessage = null;
return(result);
}
public async Task <PushResult> Push(QueueMessage message)
{
try
{
QueueClient cc;
if (_queue.Options.Acknowledge == QueueAckDecision.WaitForAcknowledge)
{
Tuple <QueueClient, int> tuple = await _queue.GetNextAvailableRRClient(_roundRobinIndex);
cc = tuple.Item1;
if (cc != null)
{
_roundRobinIndex = tuple.Item2;
}
}
else
{
cc = _queue.GetNextRRClient(ref _roundRobinIndex);
}
/*
* //if to process next message is requires previous message acknowledge, wait here
* if (_queue.Options.Acknowledge == QueueAckDecision.WaitForAcknowledge)
* await _queue.WaitForAcknowledge(message);
*/
if (cc == null)
{
_queue.AddMessage(message, false);
return(PushResult.NoConsumers);
}
ProcessingMessage = message;
PushResult result = await ProcessMessage(message, cc);
ProcessingMessage = null;
return(result);
}
catch (Exception e)
{
_queue.Server.SendError("PUSH", e, $"QueueName:{_queue.Name}, State:RoundRobin");
return(PushResult.Error);
}
}
/// <summary>
/// Push urls to baidu.com.
/// </summary>
/// <param name="site"></param>
/// <param name="token"></param>
/// <param name="urls"></param>
/// <returns></returns>
public static IBaiduPushResult Push(string site, string token, bool isOriginal, IEnumerable <string> urls)
{
string content = null;
PushResult pushResult = null;
HttpWebRequest request = CreatePushRequest(site, token, isOriginal);
byte[] buffer = g_bufferManager.TakeBuffer(BUFFER_SIZE);
byte[] data = Encoding.UTF8.GetBytes(urls.StringJoin("\r\n"));
request.ContentLength = data.Length;
try {
using (Stream writer = request.GetRequestStream()) {
writer.Write(data, 0, data.Length);
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) {
if (!string.IsNullOrWhiteSpace(content = response.GetResponseString(buffer)))
{
pushResult = new JavaScriptSerializer().Deserialize <PushResult>(content);
}
}
} catch (WebException ex) {
try {
using (HttpWebResponse response = (HttpWebResponse)ex.Response) {
if (response != null)
{
if (!string.IsNullOrWhiteSpace(content = response.GetResponseString(buffer)))
{
pushResult = new JavaScriptSerializer().Deserialize <PushResult>(content);
}
}
else
{
throw ex;
}
}
} catch {
throw ex;
}
} finally {
g_bufferManager.ReturnBuffer(buffer);
}
return(pushResult);
}
/// <summary>
/// Start to process all pending messages.
/// This method is called after a client is subscribed to the queue.
/// </summary>
private async Task ProcessPendingMessages(LinkedList <QueueMessage> list)
{
int max = list.Count;
for (int i = 0; i < max; i++)
{
QueueMessage message;
lock (list)
{
if (list.Count == 0)
{
return;
}
message = list.First.Value;
list.RemoveFirst();
message.IsInQueue = false;
}
try
{
PushResult pr = await ProcessMessage(message);
if (pr == PushResult.NoConsumers)
{
_queue.AddMessage(message, false);
return;
}
}
catch (Exception ex)
{
_queue.Info.AddError();
try
{
Decision decision = await _queue.DeliveryHandler.ExceptionThrown(_queue, message, ex);
await _queue.ApplyDecision(decision, message);
}
catch //if developer does wrong operation, we should not stop
{
}
}
}
}
public async Task <PushResult> Push(QueueMessage message, MqClient sender)
{
QueueMessage held = GetFirstMessageFromQueue(message);
ChannelClient cc = _queue.Channel.GetNextRRClient(ref _roundRobinIndex);
if (cc == null)
{
_queue.AddMessage(held, false);
return(PushResult.NoConsumers);
}
ProcessingMessage = held;
PushResult result = await ProcessMessage(held, cc);
ProcessingMessage = null;
await _queue.Trigger();
return(result);
}
public async Task <PushResult> Push(QueueMessage message, MqClient sender)
{
//if we have an option maximum wait duration for message, set it after message joined to the queue.
//time keeper will check this value and if message time is up, it will remove message from the queue.
if (_queue.Options.MessageTimeout > TimeSpan.Zero)
{
message.Deadline = DateTime.UtcNow.Add(_queue.Options.MessageTimeout);
}
QueueMessage held = GetFirstMessageFromQueue(message);
ProcessingMessage = held;
PushResult result = await ProcessMessage(held);
ProcessingMessage = null;
await _queue.Trigger();
return(result);
}
private void printPushResult(URIish uri, PushResult result)
{
shownUri = false;
bool everythingUpToDate = true;
foreach (RemoteRefUpdate rru in result.RemoteUpdates)
{
if (rru.Status == RemoteRefUpdate.UpdateStatus.UP_TO_DATE)
{
if (Verbose)
{
printRefUpdateResult(uri, result, rru);
}
}
else
{
everythingUpToDate = false;
}
}
foreach (RemoteRefUpdate rru in result.RemoteUpdates)
{
if (rru.Status == RemoteRefUpdate.UpdateStatus.OK)
{
printRefUpdateResult(uri, result, rru);
}
}
foreach (RemoteRefUpdate rru in result.RemoteUpdates)
{
if (rru.Status != RemoteRefUpdate.UpdateStatus.OK && rru.Status != RemoteRefUpdate.UpdateStatus.UP_TO_DATE)
{
printRefUpdateResult(uri, result, rru);
}
}
if (everythingUpToDate)
{
OutputStream.WriteLine("Everything up-to-date");
}
}
/// <summary>
/// Handles pushing a message into a queue
/// </summary>
private async Task HandlePush(MqClient client, HorseMessage message, HorseQueue queue, bool answerSender)
{
//check authority
foreach (IClientAuthorization authorization in _server.Authorizations)
{
bool grant = await authorization.CanMessageToQueue(client, queue, message);
if (!grant)
{
if (answerSender && !string.IsNullOrEmpty(message.MessageId))
{
await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized));
}
return;
}
}
//prepare the message
QueueMessage queueMessage = new QueueMessage(message);
queueMessage.Source = client;
//push the message
PushResult result = await queue.Push(queueMessage, client);
if (result == PushResult.StatusNotSupported)
{
if (answerSender)
{
await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized));
}
}
else if (result == PushResult.LimitExceeded)
{
if (answerSender)
{
await client.SendAsync(message.CreateResponse(HorseResultCode.LimitExceeded));
}
}
}
public virtual void TestTrackingUpdate()
{
Repository db2 = CreateBareRepository();
string remote = "origin";
string branch = "refs/heads/master";
string trackingBranch = "refs/remotes/" + remote + "/master";
Git git = new Git(db);
RevCommit commit1 = git.Commit().SetMessage("Initial commit").Call();
RefUpdate branchRefUpdate = db.UpdateRef(branch);
branchRefUpdate.SetNewObjectId(commit1.Id);
branchRefUpdate.Update();
RefUpdate trackingBranchRefUpdate = db.UpdateRef(trackingBranch);
trackingBranchRefUpdate.SetNewObjectId(commit1.Id);
trackingBranchRefUpdate.Update();
StoredConfig config = ((FileBasedConfig)db.GetConfig());
RemoteConfig remoteConfig = new RemoteConfig(config, remote);
URIish uri = new URIish(db2.Directory.ToURI().ToURL());
remoteConfig.AddURI(uri);
remoteConfig.AddFetchRefSpec(new RefSpec("+refs/heads/*:refs/remotes/" + remote +
"/*"));
remoteConfig.Update(config);
config.Save();
RevCommit commit2 = git.Commit().SetMessage("Commit to push").Call();
RefSpec spec = new RefSpec(branch + ":" + branch);
Iterable <PushResult> resultIterable = git.Push().SetRemote(remote).SetRefSpecs(spec
).Call();
PushResult result = resultIterable.Iterator().Next();
TrackingRefUpdate trackingRefUpdate = result.GetTrackingRefUpdate(trackingBranch);
NUnit.Framework.Assert.IsNotNull(trackingRefUpdate);
NUnit.Framework.Assert.AreEqual(trackingBranch, trackingRefUpdate.GetLocalName());
NUnit.Framework.Assert.AreEqual(branch, trackingRefUpdate.GetRemoteName());
NUnit.Framework.Assert.AreEqual(commit2.Id, trackingRefUpdate.GetNewObjectId());
NUnit.Framework.Assert.AreEqual(commit2.Id, db.Resolve(trackingBranch));
NUnit.Framework.Assert.AreEqual(commit2.Id, db2.Resolve(branch));
}
/// <summary>
/// 微信主动推送的通知,包括ticket定时推送通知,公众号授权、取消授权、更新授权通知
/// </summary>
/// <returns>结果</returns>
public ContentResult TicketNotify()
{
try
{
var requestStr = GetRequestStr();
PushResult res = Weixin.Notify.ReceivePushMessage(requestStr, new ConfigData());
if (res.IsSucceed)
{
return(new ContentResult {
Content = "success"
});
}
}
catch (Exception)
{
return(new ContentResult {
Content = "fail"
});
}
return(new ContentResult {
Content = "success"
});
}
