I think that this could help you. It is from an answer I found on a Google Group about recursive elements in a tree. 

The suggestion is from Brendan Owen: http://jsfiddle.net/brendanowen/uXbn6/8/

<pre><code>&lt;script type="text/ng-template" id="field_renderer.html"&gt;
 {{data.label}}
 &lt;ul&gt;
 &lt;li ng-repeat="field in data.fields" ng-include="'field_renderer.html'"&gt;&lt;/li&gt;
 &lt;/ul&gt;
&lt;/script&gt;

&lt;ul ng-controller="NestedFormCtrl"&gt;
 &lt;li ng-repeat="field in formData" ng-include="'field_renderer.html'"&gt;&lt;/li&gt;
&lt;/ul&gt;
</code></pre>

The proposed solution is about using a template that uses the ng-include directive to call itself if the current element has children.

In your case, I would try to create a template with the ng-switch directive (one case per type of label like you did) and add the ng-include at the end if there are any child labels.
 Combining what @jpmorin and @Ketan suggested (slight change on @jpmorin's answer since it doesn't actually work as is)...there's an <code>ng-if</code> to prevent "leaf children" from generating unnecessary <code>ng-repeat</code> directives:

<pre><code>&lt;script type="text/ng-template" id="field_renderer.html"&gt;
 {{field.label}}
 &lt;ul ng-if="field.Fields"&gt;
 &lt;li ng-repeat="field in field.Fields" 
 ng-include="'field_renderer.html'"&gt;
 &lt;/li&gt;
 &lt;/ul&gt;
&lt;/script&gt;
&lt;ul&gt;
 &lt;li ng-repeat="field in formData" ng-include="'field_renderer.html'"&gt;&lt;/li&gt;
&lt;/ul&gt;
</code></pre>

here's the <a href="/shell-what-is-the-current-working-version-of-gatsby-code-example" rel="dofollow">working version</a> in Plunker

How can I make recursive templates in AngularJS when using nested objects?

as far as i've seen, laptops still seem to use the old ATAPI interface which is pata based, and from the images of a supposedly compatable drive on amazon (TS-L632) it looks identical to the standard pata drives on my thinkpads - i can easily pop the one on my 3 year old laptop into a significantly older system so its a fairly common standard- so its very likely any drive that meets the atapi standards will work

To be sure you can look it up using a system information software like SIW - There should be a wmi/wmic way to do it as well

Alternately you can look at the make/model of your current drive - you can check this from <a href="/shell-open-android-virtual-device-manager-without-android-studio-on-linux-code-example" rel="dofollow">device manager</a> - and google what its specs are 

EDIT: this is the specs for the drive that model is supposed to come with - as long as the replacement drive matches up, it should work - the <a href="/go-which-gopros-have-the-same-form-factor-and-port-alignment-code-example" rel="dofollow">form factor</a> is standard, just make sure its ATAPI as opposed to slim line sata (which is a beast that's supposed to exist, but i have never seen)
 Regarding physical size: all laptop ODs usually come in two sizes - "usual" and "slim". "Slims" are thinner, and because of that often have something peculiar about disk loading and/or ejecting. Other physical dimensions are usually the same.

Of course, some laptops have customized OD physical designs (mostly the ultra-portables with ODs), and their shapes/sizes will require exactly the same physical model for replacement.

Replacing laptop optical drive (DVD, blu-ray) - what do I need to know?

There are several solutions:

<ol>
<li>You can add a public constructor and call it from a test. While it doesn't make sense, it also doesn't hurt (much).</li>
<li>Create a dummy static instance (you can call the private constructor here). Ugly but you can give the field a name to communicate your intent (<code>JUST_TO_SILENCE_COBERTURA</code> is a good name).</li>
<li>You can let your test extend the helper class. That will intrinsically call the default constructor but your helper class can't be <code>final</code> anymore.</li>
</ol>

I suggest the last approach especially because the class can't be <code>final</code> anymore. If a consumer of your code wants to add another helper method, they can now extend the existing class and receive one handle to get to all helper methods. This creates a coupling of the helper methods which communicates the intent (these belong together) - which is impossible if the helper class is <code>final</code>

If you want to prevent users to accidentally instantiate the helper class, make it <code>abstract</code> instead of using a hidden constructor.
 If you absolutely need to achieve 100% <a href="/incremental-code-coverage-for-python-unit-tests" rel="dofollow">code coverage</a> - the merits of that can be debated elsewhere :) - you can achieve it using reflection in your tests. As habit, when I implement a static-only utility class, I add in a private constructor to ensure that instances of the class can't be created. For example:

<pre><code>/** 
 * Constructs a new MyUtilities.
 * @throws InstantiationException
 */
private MyUtilities() throws InstantiationException
{
 throw new InstantiationException("Instances of this type are forbidden.");
}
</code></pre>

Then your test might look something like this:

<pre><code>@Test
public void Test_Constructor_Throws_Exception() throws IllegalAccessException, InstantiationException {
 final Class&lt;?&gt; cls = MyUtilties.class;
 final Constructor&lt;?&gt; c = cls.getDeclaredConstructors()[0];
 c.setAccessible(true);

 Throwable targetException = null;
 try {
 c.newInstance((Object[])null);
 } catch (InvocationTargetException ite) {
 targetException = ite.getTargetException();
 }

 assertNotNull(targetException);
 assertEquals(targetException.getClass(), InstantiationException.class);
}
</code></pre>

Basically, what you're doing here is getting the class by name, finding the constructors on that class type, setting it to public (the <code>setAccessible</code> call), calling the constructor with no arguments, and then ensuring that the target exception that is thrown is an <code>InstantiationException</code>.

Anyway, as you said, the 100% code coverage requirement here is kind of a pain, but it sounds like it's out of your hands, so there's little you can do about it. I've actually used approaches similar to the above in my own code, and I did find it beneficial, but not from a testing perspective. Rather, it just helped me learn a little bit more about reflection than I knew before :)
 Obtaining 100% coverage in all cases it's good, but there are some cases in which this is not possible. Of course if you have a class that is never instantiated, Cobertura will get this as a not complete test coverage, because those lines of code are actually in the class, but they're not tested.

Fact is you'll never call a private constructor (I'm assuming you've hidden the constructor by making it private), so I wouldn't bother. Test should be about getting what you're expecting, and while I agree 100% coverage is good, in some cases (like this) this isn't useful.

Have a look at 100% Code Coverage as well.

JUnit: testing helper class with only static methods

You didn't buy anything, because he didn't sell anything.

You can't resell digital downloads like a physical disk. It's right there in the <a href="/app-submission-where-do-i-put-my-eula-end-user-license-agreement" rel="dofollow">EULA</a> that no one ever reads, because you aren't buying the game, you're buying a conditional license to play the game. Your customer rights don't extend to redistribution. With most EULAs, unauthorized redistribution is grounds to terminate your license.

So basically this guy sold you something he had no right or ability to sell you. He can continue to play his game, or "sell" it to somebody else, or change his login credentials. And if anybody from Sony finds out, his account could get deleted, so you, at best, can't play the game anymore, either. At worst they delete your account, too.

What do you do? Try to get your money back and don't buy digital downloads from a third party in the future.
 It is more than likely that the person you "bought" the game from owns a digital license on their own PSN account. The way the system works is that you can buy a game from the PSN store once, but then download it on up to 5 different systems.

The seller wants you to take advantage of this policy by logging in as them, downloading the game, and using up one of the downloads. This is a total abuse of the policy and likely against the PSN EULA.

You can read a little bit more about this topic here: Sony getting stricter on PS3 and PSP game sharing and why it is a bad idea here: Why you should not game share.

<blockquote>
 Game sharing is a violation of the terms of service of the PSN and
 your account can be temporarily banned and/or suspended and with
 multiple infractions you could become permanently banned and lose
 access to all online progress and more importantly, all the money you
 spent to buy those games would be rendered useless.
</blockquote>

Can a stranger do anything malicious if I add them as a user on my PS3?

The main difference between main Ubuntu, Xubuntu, Kubuntu, and Lubuntu is the Desktop Environment. You can install one of these DEs onto your system with the following commands:

Ubuntu:

<pre><code>sudo apt-get install ubuntu-desktop
</code></pre>

Kubuntu:

<pre><code>sudo apt-get install kubuntu-desktop
</code></pre>

Xubuntu:

<pre><code>sudo apt-get install xubuntu-desktop
</code></pre>

Lubuntu:

<pre><code>sudo apt-get install lubuntu-desktop
</code></pre>

Ubuntu <a href="/in-gnome-3-how-does-one-assign-keyboard-shortcuts-for-applications-besides-the-default-applications" rel="dofollow">GNOME</a>:

<pre><code>sudo apt-get install ubuntu-gnome-desktop
</code></pre>

From Ubuntu 17.10 GNOME became the default desktop environment/shell/manager. 
So if you're running Ubuntu 17.10 forwards (including current 18.04), you can install the default desktop:

<pre><code>$ sudo apt install ubuntu-desktop
</code></pre>

To remove any of these, run the command that you used to install but instead of<code>install</code> say <code>purge</code> (i.e., <code>sudo apt-get purge kubuntu-desktop</code>). Then you also need to run this command to complete the remove:

<pre><code>sudo apt-get autoremove --purge
</code></pre>

The autoremove command removes all the packages that were installed. The way these installs work is that there is one meta-package that just depends on every package that is required for that Desktop Environment. Thus the extra packages aren't removed when the meta package is, and you need to remove them with autoremove.

This will install the Desktop Environment and most programs for each of the flavors of Ubuntu, though sometimes there are programs that are not installed by this. An install switched by using these commands will not be the same as a clean install of the Ubuntu flavor, though it should be pretty close. There is also no limit as to having more then one of these Desktop Environments. I personally kept both ubuntu-desktop and ubuntu-gnome-desktop on my computer for a while just to compare. 

I do not know about a changing to/from a Ubuntu Studio install, though I am pretty sure it isn't as easy as just changing the Desktop Environment.
 You can also keep them all, and choose which one you want to log in to. That's a good way to compare, just switch every time you boot. Every file you're created will be in the same place, every application you installed for one flavor will be available in the others.
 Ubuntu Desktop Flavours 

https://www.ubuntu.com/download/flavours

Flavours: 
Default (Gnome (17.10 - present)) ubuntu-desktop 
Budgie (simple/elegant) budgie-desktop 
Kubuntu (KDE Plasma) kubuntu-desktop 
Kylin (elegant Chinese) ubuntukylin-desktop 
Lubuntu (LXQt - light/fast) lubuntu-desktop 
MATE (GNOME 2 fork) ubuntu-mate-desktop 
Studio (Multimedia) ubuntustudio-desktop 
Xubuntu (XFce - light/configurable) xubuntu-desktop 

Install Alternative Desktop Flavour: 
(you can install multiple Desktop Flavours, then switch them as required)

<pre><code>sudo apt install [flavour]
</code></pre>

Example:

<pre><code>sudo apt install budgie-desktop
</code></pre>

Reboot after installing new flavour, then choose that new Desktop Flavour by clicking the Ubuntu icon above the password field on the login screen.

If you want to remove old flavours, make sure you're logged into a session that's not using the flavour you want to remove, then:

<pre><code>sudo apt remove --purge [flavour]
</code></pre>

Example:

<pre><code>sudo apt remove --purge ubuntu-desktop
</code></pre>

Can I change my Ubuntu Desktop into a different flavour (like Kubuntu)?

<h2>Solution 1:</h2>
You need a NAT. This configuration is commonly used to support private subnets in VPC, there's quite a detailed guide here. Once your VPC is configured to use the NAT instance all the outbound traffic will be attributed to the E<a href="/ip-spoofing-how-secure-is-to-control-access-by-users-public-ip-address" rel="dofollow">IP</a> of the NAT instance.

<blockquote>
 If so, does that instance need to be solely for this purpose or can it
 be one of the instances that's running my app?
</blockquote>

Technically you probably could, but it's not a good idea:

<ul>
<li>It's good security to have roles isolated.</li>
<li>You want your <a href="/difference-between-an-application-server-and-a-servlet-container" rel="dofollow">application server</a>s to have similar or identical load profiles. If one instance has an extra 10% load because of the NAT then you'll have to scale up prematurely when you hit the limits of that instance. This will get worse as the NAT gets busier as more instances get added to your cluster.</li>
<li>You want your application servers to be identical and ephemeral so you can tear them down and/or replace them whenever there's an issue or you need to scale. Having one application server which is different to the rest would be a major headache.</li>
</ul>

You might be able to get away with it if your instances are containerised but it's still probably not a great idea.

Also keep in mind that your NAT instance could be a single point of failure, so you may want to think about redundancy.

<h2>Solution 2:</h2>
I understand this is an old thread - for someone who has a similar use-case now, AWS nat-gateway would be a better solution. 

<hr>
<h2>Solution 3:</h2>
I don't have enough reputation to comment on the above answers, but I wanted to add some information you will need to know if using a NAT gateway to achieve this. When you create a NAT gateway, you select a subnet and an elastic IP address. 

At first, I just added the NAT gateway to the same subnet that my elastic load balancer and EC2 instances were on. Then, you have to add the NAT gateway to your route table. I added the NAT gateway as the target for the IP of my external <a href="/codeigniter-unable-to-connect-to-your-database-server-using-the-provided-settings-error-message" rel="dofollow">database server</a> that I was trying to contact. This resulted in the applications hosted in my elastic beanstalk timing out. This is because they were trying to connect to that external database through the NAT. They reached the NAT, and then the NAT tried to reach out to my server over the internet, and looked it up in the route table for the subnet it was on, which was pointing back at itself, creating a loop. 

The solution is, before you create your NAT gateway, create a new subnet just for the NAT so that the NAT has it's own subnet and route table. In the NAT's route table, point all traffic to the internet gateway. In your main route table, point your external IP to the NAT. Then, when your EC2 instances try to connect to your external IP, they will look them up in the main route table (or whatever route table you have defined for the subnets your instances are in), and find the NAT. Then, your NAT will look up that IP in it's own route table, and find the internet.

Static IP address for outgoing traffic from AWS autoscaling group

<main class="_content docs" role="main"><div class="_page _redis">
<pre>SLOWLOG subcommand [argument]</pre> <div class="metadata"> Available since 2.2.12. </div> This command is used in order to read and reset the Redis slow queries log. <h2>Redis slow log overview</h2> The Redis Slow Log is a system to log queries that exceeded a specified <a href="/fatal-error-maximum-execution-time-of-30-seconds-exceeded" rel="dofollow">execution time</a>. The execution time does not include I/O operations like talking with the client, sending the reply and so forth, but just the time needed to actually execute the command (this is the only stage of command execution where the thread is blocked and can not serve other requests in the meantime). You can configure the slow log with two parameters: slowlog-log-slower-than tells Redis what is the execution time, in microseconds, to exceed in order for the command to get logged. Note that a negative number disables the slow log, while a value of zero forces the logging of every command. slowlog-max-len is the length of the slow log. The minimum value is zero. When a new command is logged and the slow log is already at its maximum length, the oldest one is removed from the queue of logged commands in order to make space. The configuration can be done by editing <code>redis.conf</code> or while the server is running using the <a href="config-get">CONFIG GET</a> and <a href="config-set">CONFIG SET</a> commands. <h2>Reading the slow log</h2> The slow log is accumulated in memory, so no file is written with information about the slow command executions. This makes the slow log remarkably fast at the point that you can enable the logging of all the commands (setting the slowlog-log-slower-than config parameter to zero) with minor performance hit. To read the slow log the SLOWLOG GET command is used, that returns every entry in the slow log. It is possible to return only the N most recent entries passing an additional argument to the command (for instance SLOWLOG GET 10). Note that you need a recent version of redis-cli in order to read the slow log output, since it uses some features of the protocol that were not formerly implemented in redis-cli (deeply nested multi bulk replies). <h2>Output format</h2> <pre>redis 127.0.0.1:6379&gt; slowlog get 2
1) 1) (integer) 14
 2) (integer) 1309448221
 3) (integer) 15
 4) 1) "ping"
2) 1) (integer) 13
 2) (integer) 1309448128
 3) (integer) 30
 4) 1) "slowlog"
 2) "get"
 3) "100"
</pre> There are also optional fields emitted only by Redis 4.0 or greater: <pre>5) "127.0.0.1:58217"
6) "worker-123"
</pre> Every entry is composed of four (or six starting with Redis 4.0) fields: <ul> <li>A unique progressive identifier for every slow log entry.</li> <li>The <a href="/python-current-unix-timestamp-python-code-example" rel="dofollow">unix timestamp</a> at which the logged command was processed.</li> <li>The amount of time needed for its execution, in microseconds.</li> <li>The array composing the arguments of the command.</li> <li>Client IP address and port (4.0 only).</li> <li>Client name if set via the <a href="client-setname">CLIENT SETNAME</a> command (4.0 only).</li> </ul> The entry's unique ID can be used in order to avoid processing slow log entries multiple times (for instance you may have a script sending you an <a href="/send-email-alert-on-log-file-entry" rel="dofollow">email alert</a> for every new slow log entry). The ID is never reset in the course of the Redis server execution, only a <a href="/mysqld-safe-mysqld-from-pid-file-var-run-mysqld-mysqld-pid-prevent-from-server-restart" rel="dofollow">server restart</a> will reset it. <h2>Obtaining the current length of the slow log</h2> It is possible to get just the length of the slow log using the command SLOWLOG LEN. <h2>Resetting the slow log.</h2> You can reset the slow log using the SLOWLOG RESET command. Once deleted the information is lost forever. 
</div></main>

Redis slowlog

You likely need to tell cron that the shell to use is the <a href="/why-is-etc-profile-not-being-loaded-during-non-login-bash-shell-sessions" rel="dofollow">bash shell</a> as it defaults to sh. You can do that for all crontab entries by putting this line in your crontab:

<pre><code>SHELL=/bin/bash
</code></pre>

Note that this will cause all scripts in the crontab to be run under bash which may not be what you want. If you want to change the crontab line itself to just run bash, change it to this:

<pre><code>* * * * 1-5 root /bin/bash /home/xxxxxx/jmeter/VerificationService-0.0.1-SNAPSHOT/jmeter-cron-randomise.sh &gt;&gt; /home/xxxxxxx/jmeter/VerificationService-0.0.1-SNAPSHOT/cron.log 2&gt;&amp;1
</code></pre>

Note that I have also caused stderr to be written to the cron.log file (2&gt;&amp;1) which may not be what you want but is pretty common practice. This may help you further diagnose errors from the script.

Cannot run bash script from crontab when it works from command line bash

I found it's not enough for the app and account to be added as owners. I would go into your storage account &gt; IAM &gt; Add role assignment, and add the special permissions for this type of request:
<ul>
<li>Storage Blob Data Contributor</li>
<li>Storage Queue Data Contributor</li>
</ul>
 Be aware that if you want to apply "STORAGE BLOB DATA XXXX" role at the subscription level it will not work if your subscription has Azure DataBricks namespaces:
<blockquote>
If your subscription includes an Azure DataBricks namespace, roles assigned at the subscription scope will be blocked from <a href="/granting-access-for-user-sa-in-mysql-code-example" rel="dofollow">granting access</a> to blob and queue data.
</blockquote>
Source: https://docs.microsoft.com/en-us/azure/storage/common/storage-auth-aad-rbac-portal#determine-resource-scope
 I've just solved this by changing the resource requested in the GetAccessTokenAsync method from "https://storage.azure.com" to the url of my <a href="/azure-sql-database-export-to-storage-blob-failed" rel="dofollow">storage blob</a> as in this snippet:

<pre><code> public async Task&lt;StorageCredentials&gt; CreateStorageCredentialsAsync()
 {
 var provider = new AzureServiceTokenProvider();
 var token = await provider.GetAccessTokenAsync(AzureStorageContainerUrl);
 var tokenCredential = new TokenCredential(token);
 var storageCredentials = new StorageCredentials(tokenCredential);
 return storageCredentials;
 }
</code></pre>

where AzureStorageContainerUrl is set to https://xxxxxxxxx.blob.core.windows.net/

Azure Blob Storage "Authorization Permission Mismatch" error for get request with AD token

Here are a several websites that provide tests that you may be interested in.

<ul>
<li>SSL-Tools is a web-based tool that tests a SMTP server for each of the items you mentioned; it tests for STARTTLS support, a certificate that passes strict validation checks, support for perfect forward secrecy, and other stuff:

https://ssl-tools.net/mailservers</li>
<li>StartTLS is a web-based tool that tests a SMTP server and provides a simple grade, along with many details on the configuration of the SMTP server (though no testing of whether perfect forward secrecy is used):

https://starttls.info/ (see the about <a href="/typescript-wordpress-page-information-in-database-table-code-example" rel="dofollow">page information</a> about the service, or statistics about sites checked with their service)</li>
<li>CheckTLS is a web-based tool provide a way to test a SMTP server for STARTTLS server as well as whether the certificate is "ok" (i.e., it passes strict validation) and partial information on what cipher was negotiated when they connected to that SMTP server (but no information about perfect forward secrecy support):

https://www.checktls.com/</li>
<li>The following web-based tools check whether a <a href="/how-to-use-gmail-as-your-smtp-server-for-youtrack" rel="dofollow">SMTP server</a> support STARTTLS, but do not perform any of the other checks mentioned in the question:

<ul>
<li>https://luxsci.com/extranet/tlschecker.html (see http://luxsci.com/blog/how-to-tell-who-supports-tls-for-email-transmission.html for introduction)</li>
<li>https://mxtoolbox.com/</li>
</ul></li>
</ul>

If you have to check only one or two, try SSL-Tools and StartTLS.
 You can check support for starttls with <code>openssl s_client -starttls smtp ...</code>. 

<ul>
<li>With the right settings of -CAfile/-CApath you can also check the certificate chain. </li>
<li>What it does not check is the hostname, e.g. you have to manually check it.</li>
<li>It will also print out the cipher used, so you can check if it's a ECDHE or DHE cipher to see if forward secrecy gets used. </li>
<li>Maybe you might want to explicitly specify a cipher list with the -cipher option to find out if the server prefers FS ciphers even if the client put them at the and of the preference list.</li>
</ul>

Alternatively you might use Perl with a recent enough IO::Socket::SSL like this:

<pre><code>use strict;
use warnings;
use IO::Socket::SSL 1.968;
use Net::SSLGlue::SMTP;

my $host = 'mx.example.com';
my $smtp = Net::SMTP-&gt;new($host, Debug =&gt; 1) or die "connect failed";
$smtp-&gt;starttls(
 # where your CA are, has usable defaults
 # SSL_ca_file =&gt; ...,
 # SSL_ca_path =&gt; ....,
 # to restrict ciphers and set preference
 # SSL_cipher_list =&gt; '...',
) or die "starttls failed: $@|$SSL_ERROR";
print "cipher=".$smtp-&gt;get_cipher."\n";
print "cipher=".$smtp-&gt;get_sslversion."\n";
</code></pre>

This will do a proper certificate checking, does hostname verification, gives you the cipher to find out if it is forward secrecy and gives you the SSL version too. And with the latest IO::Socket::SSL versions you can also do OCSP checking to see if the certificate is revoked (see documentation in IO::Socket::SSL).
 Here are several tools that gives Qualys SSL Labs like results and support STARTTLS

<ul>
<li>testssl.sh (https://testssl.sh/)

Its a <a href="/shell-for-managing-new-creating-project-which-command-line-tool-is-used-in-django-code-example" rel="dofollow">command line tool</a> which checks a server's service on any port for the support of TLS/SSL ciphers, protocols as well as recent cryptographic flaws and more. Its quite comprehensive and major advantage is that you can scan your intranet servers as well.

<blockquote>
 eg. ./testssl.sh -t smtp aspmx.l.google.com:25
</blockquote></li>
<li>HTBridge SSL test

This is web based tool allows email and other ports.

<blockquote>
 https://www.htbridge.com/ssl/
</blockquote></li>
<li>Cryptosense Discovery

This tool allows scanning on any port. Default ports scanned (21, 22, 25, 110, 143, 389, 443, 465, 587, 636, 993, 995, 5222, 5223, 5269)

<blockquote>
 https://discovery.cryptosense.com/
</blockquote></li>
</ul>

New posts